enh: argparse subcommands, Path|None

Author: e3rd

docs/Argparse-caveats.md

@@ -1,6 +1,5 @@
 Be aware that in contrast to the argparse:
 
-* We create default values. This does make sense for most values but might pose a confusion for ex. `parser.add_argument("--path", type=Path)` which becomes `Path('.')`, not `None`.
 * When storing multiple `store_const` action to the same `dest`, order does not matter.
 * When using positional arguments before the subcommands, the order changes
 

docs/Changelog.md

@@ -4,6 +4,7 @@
 * enh: better argparse support (const support, store_false matching, subcommands)
 * feat: Added time constraint to the DatetimeTag #28
 * feat: implement unified toggle widget shortcut system across interfaces #29
+* feat: correctly handles `Path|None` and `datetime|None` syntax
 
 ## 1.0.3 (2025-06-18)
 * enh: Tk better file dialog

docs/index.md

@@ -242,11 +242,11 @@ from pathlib import Path
 from mininterface import run
 
 parser = ArgumentParser()
-parser.add_argument("input_file", type=Path, help="Path to the input file.")
-parser.add_argument("--time", type=time, help="Given time")
 subparsers = parser.add_subparsers(dest="command", required=True)
 sub1 = subparsers.add_parser("build", help="Build something.")
 sub1.add_argument("--optimize", action="store_true", help="Enable optimizations.")
+parser.add_argument("input_file", type=Path, help="Path to the input file.")
+parser.add_argument("--time", type=time, help="Given time")
 
 # Old version
 # env = parser.parse_args()

mininterface/__init__.py

@@ -212,8 +212,11 @@ class Env:
         if superform_args is not None:
             # Run Superform as multiple subcommands exist and we have to decide which one to run.
             m = get_interface(interface, title, settings, None)
-            ChooseSubcommandOverview(env_or_list, m, args=superform_args, ask_for_missing=ask_for_missing)
-            return m  # m with added `m.env`
+            try:
+                ChooseSubcommandOverview(env_or_list, m, args=superform_args, ask_for_missing=ask_for_missing)
+                return m  # m with added `m.env`
+            except Exception as e:  # some nested subcommands would fail in overview
+                env_or_list = m.select({cl.__name__: cl for cl in env_or_list if cl is not SubcommandPlaceholder})
 
     # B) A single Env object, or a list of such objects (with one is being selected via args)
     # C) No Env object

mininterface/_lib/argparse_support.py

@@ -8,22 +8,28 @@
     _StoreFalseAction,
     _StoreTrueAction,
     _SubParsersAction,
+    _VersionAction,
     Action,
     ArgumentParser,
 )
 from collections import defaultdict
-from dataclasses import Field, dataclass, field, make_dataclass
+from dataclasses import MISSING, Field, dataclass, field, make_dataclass
 from functools import cached_property
 import re
-from typing import Callable
+import sys
+from typing import Annotated, Callable, Literal, Optional
 from warnings import warn
 
+from tyro.conf import OmitSubcommandPrefixes
+
+from .. import Options
+
 from .form_dict import DataClass
-from ..tag import Tag
 
 
 try:
-    from tyro.conf import Positional
+    from tyro.constructors import PrimitiveConstructorSpec
+    from tyro.conf import Positional, arg
 except ImportError:
     from ..exceptions import DependencyRequired
 
@@ -75,14 +81,8 @@ def has_property(self):
 
 
 def parser_to_dataclass(parser: ArgumentParser, name: str = "Args") -> DataClass | list[DataClass]:
-    """Note that in contrast to the argparse, we create default values.
-    When an optional flag is not used, argparse put None, we have a default value.
-
-    This does make sense for most values and should not pose problems for truthy-values.
-    Ex. checking `if namespace.my_int` still returns False for both argparse-None and our-0.
-
-    Be aware that for Path this might pose a big difference:
-    parser.add_argument("--path", type=Path) -> becomes Path('.'), not None!
+    """
+    Note: Ex. parser.add_argument("--time", type=time) -> does work at all in argparse, here it works.
     """
     subparsers: list[_SubParsersAction] = []
 
@@ -144,6 +144,22 @@ def _make_dataclass_from_actions(
         match action:
             case _HelpAction():
                 continue
+            case _VersionAction():
+                # NOTE Should be probably implemented in tyro. Here that way:
+                # run(add_version="1.2.3")
+                # run(add_version_package="intelmq") -> get pip version
+                arg_type = Annotated[
+                    None,
+                    PrimitiveConstructorSpec(
+                        nargs="*",
+                        metavar="",
+                        instance_from_str=lambda _, v=action.version: print(v) or sys.exit(0),
+                        is_instance=lambda _: True,
+                        # NOTE tyro might not diplay anything here,
+                        # but it displays `(default: )`
+                        str_from_instance=(lambda _, v=action.version: [str(v)]),
+                    ),
+                ]
             case _SubParsersAction():
                 # Note that there is only one _SubParsersAction in argparse
                 # but to be sure, we allow multiple of them
@@ -156,6 +172,14 @@ def _make_dataclass_from_actions(
                         subparser.description,
                     )
                     subparser_fields.append((subname, sub_dc))  # required, no default
+
+                from functools import reduce
+
+                union_type = reduce(lambda a, b: a | b, [aa[1] for aa in subparser_fields])
+
+                result = OmitSubcommandPrefixes[Positional[union_type]]
+                pos_fields.append(("_subparsers", result))
+                subparser_fields.clear()
                 continue
             case _AppendAction():
                 arg_type = list[action.type or str]
@@ -185,36 +209,69 @@ def _make_dataclass_from_actions(
             case _CountAction():
                 arg_type = int
             case _:
-                arg_type = action.type or str
+                if action.type:
+                    arg_type = action.type
+                elif action.default:
+                    arg_type = type(action.default)
+                else:
+                    arg_type = str
+
+        metavar = None
+        if "default" not in opt and "default_factory" not in opt:
+            if action.choices:
+                # With the drop of Python 3.10, use:
+                # arg_type = Literal[*action.choices]
+                arg_type = Annotated[arg_type, Options(*action.choices)]
+
+            if not action.option_strings and action.default is None and action.nargs != "?":
+                opt["default"] = MISSING
+            else:
                 if action.default is None:
-                    # parser.add_argument("--path", type=Path) -> becomes Path('.'), not None!
+                    # parser.add_argument("--path", type=Path) -> becomes None, not Path('.').
                     # By default, argparse put None if not used in the CLI.
                     # Which makes tyro output the warning: annotated with type `<class 'str'>`, but the default value `None`
                     # We either make None an option by `arg_type |= None`
                     # or else we default the value.
-                    # This creates a slightly different behaviour, however, the behaviour is slightly different
-                    # nevertheless.
-                    # Ex. parser.add_argument("--time", type=time) -> does work poorly in argparse.
-                    action.default = Tag(annotation=arg_type)._make_default_value()
-        if "default" not in opt and "default_factory" not in opt:
-            opt["default"] = action.default if action.default != SUPPRESS else None
+                    if arg_type is not None:
+                        arg_type |= None
+                opt["default"] = action.default if action.default != SUPPRESS else None
 
         # build a dataclass field, either optional, or positional
-        met = {"metadata": {"help": action.help}}
+        opt["metadata"] = {"help": action.help}
         if action.option_strings:
             # normal_fields.append((action.dest, arg_type, field(**opt, **met)))
-            normal_fields.append((af.name, arg_type, field(**opt, **met)))
+            # Annotated[arg_type, arg(metavar=metavar)]
+            normal_fields.append((af.name, arg_type, field(**opt)))
 
             # Generate back-compatible property if dest != field_name
             if af.name != action.dest and not af.has_property:
                 af.add(lambda self, field_name=af.name: getattr(self, field_name))
-
         else:
-            pos_fields.append((action.dest, Positional[arg_type], field(**met)))
+            pos_fields.append((action.dest, Positional[arg_type], field(**opt)))
+
+    # Subparser can have the same field name as the parser. We use the latter.
+    # Ex:
+    #   parser.add_argument('--level', type=int, default=1)
+    #   subparsers = parser.add_subparsers(dest='command')
+    #   run_parser = subparsers.add_parser('run')
+    #   run_parser.add_argument('--level', type=int, default=5)
+    uniq_fields = []
+    seen = set()
+    # for f in reversed(subparser_fields + pos_fields + normal_fields):
+    for f in reversed(pos_fields + normal_fields):
+        if f[0] not in seen:
+            seen.add(f[0])
+            uniq_fields.append(f)
+
+    # if subparser_fields:
+    #     from functools import reduce
+    #     union_type = reduce(lambda a, b: a | b, [aa[1] for aa in subparser_fields])
+    #     result = OmitSubcommandPrefixes[Positional[union_type]]
+    #     uniq_fields.append(("_subparsers",  result ))
 
     dc = make_dataclass(
         name,
-        subparser_fields + pos_fields + normal_fields,
+        reversed(uniq_fields),
         namespace={k: prop.generate_property() for k, prop in properties.items()},
     )
     if helptext or description:

mininterface/_lib/auxiliary.py

@@ -226,3 +226,16 @@ def validate_annotated_type(meta, value) -> bool:
     else:
         raise NotImplementedError(f"Unknown predicated {meta}")
     return True
+
+def allows_none(annotation) -> bool:
+    """True, if annotation allows None: `int | None`, `Optional[int]`, `Union[int,None]`."""
+    if annotation is None:
+        return True
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    # if NoneType in get_args(self.annotation):
+
+    if origin is Union or origin is UnionType:
+        return any(arg is type(None) for arg in args)
+    return False

mininterface/_lib/cli_parser.py

@@ -70,6 +70,7 @@
 """ Used to intercept an error message from tyro """
 reraise: Optional[Callable] = None
 """ Reraise the intercepted tyro error message """
+subparser_used = None
 
 
 class Patches:
@@ -82,9 +83,10 @@ def custom_error(self: TyroArgumentParser, message: str):
         the error message function. Then, we reconstruct the missing options.
         Thanks to this we will be able to invoke a UI dialog with the missing options only.
         """
-        global eavesdrop, reraise
+        global eavesdrop, reraise, subparser_used
         if not message.startswith("the following arguments are required:"):
             return super(TyroArgumentParser, self).error(message)
+        subparser_used = self
         eavesdrop = message
 
         def reraise():
@@ -168,20 +170,17 @@ def parse_cli(
         patches.append(patch.object(TyroArgumentParser, "error", Patches.custom_error))
     if add_verbose:  # Mock parser to add verbosity
         # The verbose flag is added only if neither the env_class nor any of the subcommands have the verbose flag already
-        try:
-            if all("verbose" not in cl.__annotations__ for cl in env_classes):
-                patches.extend(
-                    (
-                        patch.object(TyroArgumentParser, "__init__", Patches.custom_init),
-                        patch.object(
-                            TyroArgumentParser,
-                            "parse_known_args",
-                            Patches.custom_parse_known_args,
-                        ),
-                    )
+        if all("verbose" not in cl.__annotations__ for cl in env_classes):
+            patches.extend(
+                (
+                    patch.object(TyroArgumentParser, "__init__", Patches.custom_init),
+                    patch.object(
+                        TyroArgumentParser,
+                        "parse_known_args",
+                        Patches.custom_parse_known_args,
+                    ),
                 )
-        except Exception as e:  # TODO
-            warnings.warn("Cannot add verbose flag")
+            )
 
     # Run the parser, with the mocks
     try:
@@ -204,7 +203,7 @@ def parse_cli(
             # Some required arguments are missing. Determine which.
             wf: dict[str, Tag] = {}
 
-            # There are multiple dataclasses, query which is chosen
+            # # There are multiple dataclasses, query which is chosen
             if len(env_classes) == 1:
                 env = env_classes[0]
                 parser: ArgumentParser = get_parser(type_form, **kwargs)
@@ -219,6 +218,8 @@ def parse_cli(
                     subargs = args[1:]
             if not env:
                 raise NotImplementedError("This case of nested dataclasses is not implemented. Raise an issue please.")
+            # NOTE For subparsers, I might directly use the subparser that failed.
+            # parser = subparser_used
 
             # Determine missing argument of the given dataclass
             positionals = (p for p in parser._actions if p.default != argparse.SUPPRESS)
@@ -228,6 +229,7 @@ def parse_cli(
                 if "--" not in arg:
                     # Positional
                     # Ex: `The following arguments are required: PATH, INT, STR`
+                    # Ex: `The following arguments are required: {get,pop,send}`
                     argument = next(positionals)
                     register_wrong_field(env, kwargs, wf, argument, exception, eavesdrop)
                 else:
@@ -296,6 +298,7 @@ def argument_to_field_name(env_class: EnvClass, argument: Action):
     # Why using mro? Find the field in the dataclass and all of its parents.
     # Useful when handling subcommands, they share a common field.
     field_name = argument.dest
+    field_name = field_name.replace(" (positional)", "")
     if not any(field_name in ann for ann in yield_annotations(env_class)):
         field_name = field_name.replace("-", "_")
     if not any(field_name in ann for ann in yield_annotations(env_class)):

mininterface/_tk_interface/adaptor.py

@@ -1,5 +1,5 @@
 import sys
-from tkinter import LEFT, Button, Frame, Label, TclError, Text, Tk, Widget
+from tkinter import LEFT, Button, Frame, Label, StringVar, TclError, Text, Tk, Widget
 from typing import TYPE_CHECKING, Any, Callable
 
 try:
@@ -125,7 +125,7 @@ def run_dialog(self, form: TagDict, title: str = "", submit: bool | str = True)
 
         # status bar would look like this
         # status_var = StringVar()
-        # status_var.set("F1 – help")
+        # status_var.set("|".join(self.shortcuts))
         # status_label = Label(self.frame, textvariable=status_var, relief="sunken", anchor="w", padx=5)
         # status_label.pack(side="bottom", fill="x", pady=(20, 0))
 

mininterface/tag/datetime_tag.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass
-from datetime import date, datetime, time, date as date_
+from datetime import date, datetime, time, date as date_, time as time_
 from typing import Union
+
+from .._lib.auxiliary import allows_none
+
 from .tag import Tag, TagValue, UiValue
 
 
@@ -69,12 +72,14 @@ class Env:
     full_precision: bool = False
     """ Include full time precison, seconds, microseconds. """
 
-    before: Union[date_, None] = None
+    before: date_ | None = None
     """ The maximum allowed date/datetime value. """
 
-    after: Union[date_, None] = None
+    after: date_ | None = None
     """ The minimum allowed date/datetime value. """
 
+    _caster: type[date_|time_|datetime] = date_
+
     # NOTE calling DatetimeTag("2025-02") should convert str to date?
     def __post_init__(self):
         super().__post_init__()
@@ -122,12 +127,20 @@ def validate_date_range(tag: Tag) -> Union[bool, str]:
 
             self._add_validation(validate_date_range)
 
+        self._caster = self.annotation
+        if allows_none(self.annotation):
+            for _, subtype in self._get_possible_types():
+                self._caster = subtype
+                break
+
     def __hash__(
         self,
     ):  # every Tag child must have its own hash method to be used in Annotated
         return super().__hash__()
 
     def _make_default_value(self):
+        if allows_none(self.annotation):
+            return None
         if self.annotation is datetime:
             return datetime.now()
         if self.annotation is date:
@@ -137,11 +150,12 @@ def _make_default_value(self):
         raise ValueError("Could not determine the default value for %s", self)
 
     def update(self, ui_value: UiValue) -> bool:
+        if ui_value == "" and allows_none(self.annotation):
+            return True
         if isinstance(ui_value, str):
             try:
-                ui_value = self.annotation.fromisoformat(ui_value)
-            except ValueError:
-                # allow annotations like `time | None`
-                # Empty input will still have chance to be resolved further.
-                pass
+                ui_value = self._caster.fromisoformat(ui_value)
+            except ValueError as e:
+                self.set_error_text(str(e))
+                return False
         return super().update(ui_value)