mininterface 1.1.4__tar.gz → 1.2.1__tar.gz

{mininterface-1.1.4 → mininterface-1.2.1}/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.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
 Author: Edvard Rejthar

{mininterface-1.1.4 → 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.1.4 → mininterface-1.2.1}/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.1}/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.2.1/mininterface/_lib/cli_flags.py

@@ -0,0 +1,234 @@
+from argparse import ArgumentParser
+import logging
+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: str = ""
+    _add_quiet: bool = False
+
+    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, "config": True}
+        # verbosity
+        match add_verbose:
+            case bool():
+                self._add_verbose = add_verbose
+            case int():
+                self._add_verbose = True
+                self.default_verbosity = add_verbose
+                self._verbosity_sequence = list(range(add_verbose - 10, -1, -10))
+            case list() | tuple():
+                self._add_verbose = True
+                self.default_verbosity = add_verbose[0]
+                self._verbosity_sequence = add_verbose[1:]
+        self._add_quiet = add_quiet
+
+        # version
+        if add_version:
+            self.version = add_version
+        elif add_version_package:
+            try:
+                from importlib.metadata import PackageNotFoundError, version
+            except ImportError:
+                self.version = f"cannot determine version"
+            try:
+                self.version = version(add_version_package)
+            except PackageNotFoundError:
+                self.version = f"package {add_version_package} not found"
+
+        # 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)
+        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 or self.add_config
+
+    def _attr_not_present(self, flag, env_classes):
+        return all(flag not in cl.__annotations__ for cl in env_classes)
+
+    @property
+    def add_verbose(self):
+        return self._add_verbose and self._enabled["verbose"]
+
+    @property
+    def add_version(self):
+        return self.version and self._enabled["version"]
+
+    @property
+    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.
+        * add_verbose = True ( default level = WARNING )
+            * -v -> logging.INFO
+            * -vv -> logging.DEBUG
+            * -vvv -> logging.NOTSET
+        * add_verbose = default level INFO
+            * -v -> logging.DEBUG
+            * -vv -> logging.NOTSET
+        * add_verbose = (40, 35, 30, 25)
+            * -v -> 35
+            * -vv -> logging.INFO
+            * -vvv -> 25
+            * -vvv -> logging.NOTSET
+
+        Args:
+            count: number of times `--verbose` flag is used. Negative count means the `--quiet` flag is used.
+
+        Returns:
+            int: log level
+        """
+        if count == -1:  # quiet flag
+            return logging.ERROR
+        if not count:
+            return self.default_verbosity
+        if not self._verbosity_sequence:
+            seq = logging.INFO, logging.DEBUG
+        else:
+            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)