mininterface 1.0.3__tar.gz → 1.0.4__tar.gz

{mininterface-1.0.3 → mininterface-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mininterface
-Version: 1.0.3
+Version: 1.0.4
 Summary: A minimal access to GUI, TUI, CLI and config
 License: LGPL-3.0-or-later
 Author: Edvard Rejthar
@@ -187,7 +187,7 @@ These projects have the code base reduced thanks to the mininterface:
 Take a look at the following example.
 
 1. We define any Env class.
-2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompter for
+2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompted for
 3. Then, we use various dialog methods, like [`confirm`][mininterface.Mininterface.confirm], [`select`][mininterface.Mininterface.select] or [`form`][mininterface.Mininterface.form].
 
 Below, you find the screenshots how the program looks in various environments ([graphic](Interfaces.md#guiinterface-or-tkinterface-or-gui) interface, [web](Interfaces.md#webinterface-or-web) interface...).
@@ -280,11 +280,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()
@@ -335,4 +335,4 @@ print(m.env.time)  # -> 14:21
 If you're sure enough to start using *Mininterface*, convert the argparse into a dataclass. Then, the IDE will auto-complete the hints as you type.
 
 !!! warning
-    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`.
+    The argparse support is considered mostly for your evaluation as there are some [`differences`](Argparse-caveats.md) for advanced argparse CLI interfaces.

{mininterface-1.0.3 → mininterface-1.0.4}/README.md

@@ -149,7 +149,7 @@ These projects have the code base reduced thanks to the mininterface:
 Take a look at the following example.
 
 1. We define any Env class.
-2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompter for
+2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompted for
 3. Then, we use various dialog methods, like [`confirm`][mininterface.Mininterface.confirm], [`select`][mininterface.Mininterface.select] or [`form`][mininterface.Mininterface.form].
 
 Below, you find the screenshots how the program looks in various environments ([graphic](Interfaces.md#guiinterface-or-tkinterface-or-gui) interface, [web](Interfaces.md#webinterface-or-web) interface...).
@@ -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()
@@ -297,4 +297,4 @@ print(m.env.time)  # -> 14:21
 If you're sure enough to start using *Mininterface*, convert the argparse into a dataclass. Then, the IDE will auto-complete the hints as you type.
 
 !!! warning
-    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`.
+    The argparse support is considered mostly for your evaluation as there are some [`differences`](Argparse-caveats.md) for advanced argparse CLI interfaces.

{mininterface-1.0.3 → mininterface-1.0.4}/mininterface/__init__.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal, Optional, Sequence, Type
 
+
 from .exceptions import Cancelled, DependencyRequired, InterfaceNotAvailable
 from ._lib.form_dict import DataClass, EnvClass
 from .interfaces import get_interface
@@ -16,11 +17,11 @@ from .tag.alias import Options, Validation
 try:
     from ._lib.start import ChooseSubcommandOverview, Start
     from .cli import Command, SubcommandPlaceholder
+    from ._lib.argparse_support import parser_to_dataclass
     from ._lib.cli_parser import (
         assure_args,
         parse_cli,
         parse_config_file,
-        parser_to_dataclass,
     )
 except DependencyRequired as e:
     assure_args, parse_cli, parse_config_file, parser_to_dataclass = (e,) * 4
@@ -40,14 +41,7 @@ def run(
     add_verbose: bool = True,
     ask_for_missing: bool = True,
     # We do not use InterfaceType as a type here because we want the documentation to show full alias:
-    interface: (
-        Type[Mininterface]
-        | Literal["gui"]
-        | Literal["tui"]
-        | Literal["text"]
-        | Literal["web"]
-        | None
-    ) = None,
+    interface: Type[Mininterface] | Literal["gui"] | Literal["tui"] | Literal["text"] | Literal["web"] | None = None,
     args: Optional[Sequence[str]] = None,
     settings: Optional[MininterfaceSettings] = None,
     **kwargs
@@ -218,24 +212,21 @@ def run(
         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
 
     # Parse CLI arguments, possibly merged from a config file.
-    kwargs, settings = parse_config_file(
-        env_or_list or _Empty, config_file, settings, **kwargs
-    )
+    kwargs, settings = parse_config_file(env_or_list or _Empty, config_file, settings, **kwargs)
     if env_or_list:
         # B) single Env object
         # Load configuration from CLI and a config file
-        env, wrong_fields = parse_cli(
-            env_or_list, kwargs, add_verbose, ask_for_missing, args
-        )
+        env, wrong_fields = parse_cli(env_or_list, kwargs, add_verbose, ask_for_missing, args)
         m = get_interface(interface, title, settings, env)
 
         # Empty CLI → GUI edit

{mininterface-1.0.3 → mininterface-1.0.4}/mininterface/__main__.py

@@ -9,6 +9,7 @@ try:
     from tyro.conf import Positional
 except ImportError:
     from .exceptions import DependencyRequired
+
     raise DependencyRequired("basic").exit()
 
 from . import run
@@ -36,7 +37,7 @@ Showcase_Type = Literal[1, 2]
 
 @dataclass
 class Alert(Command):
-    """ Dialog: Display the OK dialog with text. """
+    """Dialog: Display the OK dialog with text."""
 
     text: Positional[str]
 
@@ -46,7 +47,7 @@ class Alert(Command):
 
 @dataclass
 class Ask(Command):
-    """ Dialog: Prompt the user to input a value.
+    """Dialog: Prompt the user to input a value.
     By default, we input a str, by the second parameter, you can infer a type,
     ex. `mininterface --ask 'My heading' int`
     """
@@ -77,12 +78,15 @@ class Ask(Command):
                 v = Path
             case "date":
                 from datetime import date
+
                 v = date
             case "datetime":
                 from datetime import datetime
+
                 v = datetime
             case "time":
                 from datetime import time
+
                 v = time
             case "file":
                 v = PathTag(is_file=True)
@@ -95,7 +99,7 @@ class Ask(Command):
 
 @dataclass
 class Confirm(Command):
-    """ Dialog: Display confirm box. Returns 0 / 1. """
+    """Dialog: Display confirm box. Returns 0 / 1."""
 
     text: Positional[str]
     focus: Positional[Literal["yes", "no"]] = "yes"
@@ -108,7 +112,8 @@ class Confirm(Command):
 
 @dataclass
 class Select(Command):
-    """ Dialog: Prompt the user to select. """
+    """Dialog: Prompt the user to select."""
+
     options: Positional[list[str]]
     title: str = ""
 
@@ -118,7 +123,7 @@ class Select(Command):
 
 @dataclass
 class Integrate(Command):
-    """ Integrate to the system. Generates a bash completion for the given program. """
+    """Integrate to the system. Generates a bash completion for the given program."""
 
     cmd: Positional[File]
     """Path to the program using mininterface.
@@ -126,17 +131,18 @@ class Integrate(Command):
     """
 
     def run(self):
-        environ["MININTERFACE_INTEGRATE_TO_SYSTEM"] = '1'
+        environ["MININTERFACE_INTEGRATE_TO_SYSTEM"] = "1"
         srun(self.cmd.absolute(), env=environ)
         quit()
 
 
 @dataclass
 class Showcase:
-    """ Prints various form just to show what's possible.
+    """Prints various form just to show what's possible.
     Choose the interface by MININTERFACE_INTERFACE=...
     Ex. MININTERFACE_INTERFACE=tui mininterface showcase 2
     """
+
     showcase: Positional[Showcase_Type] = 1
 
 
@@ -151,11 +157,17 @@ class Web(Command):
 
     def run(self):
         from ._web_interface import WebInterface
+
         WebInterface(cmd=self.cmd, port=self.port)
 
 
 def main():
-    with run([Alert, Ask, Confirm, Select, Integrate, Showcase,  Web], prog="Mininterface", description=__doc__, ask_for_missing=False) as m:
+    with run(
+        [Alert, Ask, Confirm, Select, Integrate, Showcase, Web],
+        prog="Mininterface",
+        description=__doc__,
+        ask_for_missing=False,
+    ) as m:
         pass
 
     if isinstance(m.env, Showcase):

mininterface-1.0.4/mininterface/_lib/argparse_support.py

@@ -0,0 +1,284 @@
+from argparse import (
+    SUPPRESS,
+    _AppendAction,
+    _AppendConstAction,
+    _CountAction,
+    _HelpAction,
+    _StoreConstAction,
+    _StoreFalseAction,
+    _StoreTrueAction,
+    _SubParsersAction,
+    _VersionAction,
+    Action,
+    ArgumentParser,
+)
+from collections import defaultdict
+from dataclasses import MISSING, Field, dataclass, field, make_dataclass
+from functools import cached_property
+import re
+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
+
+
+try:
+    from tyro.constructors import PrimitiveConstructorSpec
+    from tyro.conf import Positional, arg
+except ImportError:
+    from ..exceptions import DependencyRequired
+
+    raise DependencyRequired("basic")
+
+
+class Property:
+    def __init__(self):
+        self._usages = []
+
+    def add(self, callback: Callable):
+        self._usages.append(callback)
+
+    def generate_property(self):
+        def _(this):
+            for clb in self._usages:
+                v = clb(this)
+                if v is not None:
+                    return v
+
+        return property(_)
+
+
+@dataclass
+class ArgparseField:
+
+    action: Action
+    properties: dict[str, Property]
+
+    @cached_property
+    def name(self):
+        if n := self.action.option_strings:
+            # --get-one → get_one
+            return re.sub(r"^--?", "", self.action.option_strings[0]).replace("-", "_")
+        else:
+            raise ValueError(f"Cannot load argparse, due to field {self.action}")
+
+    def add(self, callback: Callable):
+        if self.action.dest == self.name:
+            raise NotImplementedError(
+                f"Cannot load argparse, due to field {self.action}. It must be visible from CLI and cannot"
+                "be read directly from the program. Solution: Do not use argparse or add a .dest parameter."
+            )
+        self.properties[self.action.dest].add(callback)
+
+    @property
+    def has_property(self):
+        return self.action.dest in self.properties
+
+
+def parser_to_dataclass(parser: ArgumentParser, name: str = "Args") -> DataClass | list[DataClass]:
+    """
+    Note: Ex. parser.add_argument("--time", type=time) -> does work at all in argparse, here it works.
+    """
+    subparsers: list[_SubParsersAction] = []
+
+    normal_actions: list[Action] = []
+    has_positionals = False
+    for action in parser._actions:
+        match action:
+            case _HelpAction():
+                continue
+            case _SubParsersAction():
+                if has_positionals:
+                    warn(
+                        "This CLI parser have a subcommand placed after positional arguments. The order of arguments changes, see --help."
+                    )
+                subparsers.append(action)
+            case _:
+                if not action.option_strings:
+                    has_positionals = True
+                normal_actions.append(action)
+
+    if subparsers:
+        return [
+            _make_dataclass_from_actions(
+                normal_actions + subactions._actions,
+                subname,
+                help_,
+                subactions.description,
+            )
+            for subparser in subparsers
+            for subname, subactions, help_ in _loop_SubParsersAction(subparser)
+        ]
+    else:
+        return _make_dataclass_from_actions(normal_actions, name, None, parser.description)
+
+
+def _loop_SubParsersAction(subparser: _SubParsersAction):
+    return [
+        (subname, subactions, ch_act.help)
+        for (subname, subactions), ch_act in zip(subparser.choices.items(), subparser._choices_actions)
+    ]
+
+
+def _make_dataclass_from_actions(
+    actions: list[Action], name, helptext: str | None, description: str | None
+) -> DataClass:
+    const_actions = defaultdict(list[ArgparseField])
+    normal_fields: list[tuple[str, type, Field]] = []
+    pos_fields: list[tuple[str, type, Field]] = []
+    properties = defaultdict(Property)
+    """ Sometimes, the action.dest differs from the field name.
+    Field name is exposed to the CLI, action.dest is used in the program.
+    """
+    subparser_fields: list[tuple[str, type]] = []
+
+    for action in actions:
+        af = ArgparseField(action, properties)
+        opt = {}
+
+        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
+                # This probably makes a different CLI output than the original argparse but should work.
+                for subname, subparser, help_ in _loop_SubParsersAction(action):
+                    sub_dc = _make_dataclass_from_actions(
+                        subparser._actions,
+                        subname.capitalize(),
+                        help_,
+                        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]
+                opt["default_factory"] = list
+            case _AppendConstAction():
+                # `--one --two` -> env.section = [one, two]
+                arg_type = bool
+                opt["default"] = False
+                const_actions[af.action.dest].append(af)
+                af.add(
+                    lambda self, af=af: (
+                        [_af.action.const for _af in const_actions[af.action.dest] if getattr(self, _af.name)]
+                    )
+                )
+            case _StoreTrueAction():
+                arg_type = bool
+            case _StoreFalseAction():
+                arg_type = bool
+                opt["default"] = False
+                af.add(lambda self, field_name=af.name: not getattr(self, field_name))
+            case _StoreConstAction():
+                arg_type = bool
+                opt["default"] = False
+                af.add(
+                    lambda self, field_name=af.name, const=action.const: (const if getattr(self, field_name) else None)
+                )
+            case _CountAction():
+                arg_type = int
+            case _:
+                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 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.
+                    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
+        opt["metadata"] = {"help": action.help}
+        if action.option_strings:
+            # normal_fields.append((action.dest, 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(**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,
+        reversed(uniq_fields),
+        namespace={k: prop.generate_property() for k, prop in properties.items()},
+    )
+    if helptext or description:
+        trimmed = (helptext or "").strip()
+        needs_colon = trimmed and description and trimmed[-1] not in (".", ":", "!", "?", "…")
+
+        separator = ": " if needs_colon else ("\n" if trimmed else "")
+        dc.__doc__ = trimmed + separator + (description or "")
+
+    return dc

{mininterface-1.0.3 → mininterface-1.0.4}/mininterface/_lib/auxiliary.py

@@ -25,7 +25,7 @@ common_iterables = list, tuple, set
 
 
 def flatten(d: dict[str, T | dict], include_keys: Optional[Callable[[str], list]] = None) -> Iterable[T]:
-    """ Recursively traverse whole dict """
+    """Recursively traverse whole dict"""
     for k, v in d.items():
         if isinstance(v, dict):
             if include_keys:
@@ -37,7 +37,7 @@ def flatten(d: dict[str, T | dict], include_keys: Optional[Callable[[str], list]
 
 # NOTE: Not used.
 def flatten_keys(d: dict[KT, T | dict]) -> Iterable[tuple[KT, T]]:
-    """ Recursively traverse whole dict """
+    """Recursively traverse whole dict"""
     for k, v in d.items():
         if isinstance(v, dict):
             yield from flatten_keys(v)
@@ -61,17 +61,19 @@ def get_terminal_size():
         # stty: 'standard input': Inappropriate ioctl for device
         # I do not know how to suppress this warning.
         # NOTE why not using os.get_terminal_size()
-        height, width = (int(s) for s in os.popen('stty size', 'r').read().split())
+        height, width = (int(s) for s in os.popen("stty size", "r").read().split())
         return height, width
     except (OSError, ValueError):
         return 0, 0
 
 
 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. """
+    """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 {action.dest.replace("-", "_"): re.sub(r"\((default|fixed to|required).*\)", "", action.help or "")
-            for action in parser._actions}
+    return {
+        action.dest.replace("-", "_"): re.sub(r"\((default|fixed to|required).*\)", "", action.help or "")
+        for action in parser._actions
+    }
 
 
 def get_description(obj, param: str) -> str:
@@ -90,7 +92,7 @@ def yield_annotations(dataclass):
 
 
 def matches_annotation(value, annotation) -> bool:
-    """ Check whether the value type corresponds to the annotation.
+    """Check whether the value type corresponds to the annotation.
     Because built-in isinstance is not enough, it cannot determine parametrized generics.
     """
     # union, including Optional and UnionType
@@ -155,7 +157,7 @@ def subclass_matches_annotation(cls, annotation) -> bool:
 
 
 def serialize_structure(obj):
-    """ Ex: [Path("/tmp"), Path("/usr"), 1] -> ["/tmp", "/usr", 1]. """
+    """Ex: [Path("/tmp"), Path("/usr"), 1] -> ["/tmp", "/usr", 1]."""
     if isinstance(obj, (str, int, float)):
         return obj
     elif isinstance(obj, Iterable) and not isinstance(obj, (str, bytes)):
@@ -165,7 +167,7 @@ def serialize_structure(obj):
 
 
 def dataclass_asdict_no_defaults(obj) -> dict:
-    """ Ignore the dataclass default values. """
+    """Ignore the dataclass default values."""
     if not hasattr(obj, "__dataclass_fields__"):
         return obj
 
@@ -182,7 +184,7 @@ def dataclass_asdict_no_defaults(obj) -> dict:
 
 
 def merge_dicts(d1: dict, d2: dict):
-    """ Recursively merge second dict to the first. """
+    """Recursively merge second dict to the first."""
     for key, value in d2.items():
         if isinstance(value, dict) and isinstance(d1.get(key), dict):
             merge_dicts(d1[key], value)
@@ -192,14 +194,14 @@ def merge_dicts(d1: dict, d2: dict):
 
 
 def naturalsize(value: float | str, *args) -> str:
-    """ For a bare interface, humanize might not be installed. """
+    """For a bare interface, humanize might not be installed."""
     if naturalsize_:
         return naturalsize_(value, *args)
     return str(value)
 
 
 def validate_annotated_type(meta, value) -> bool:
-    """ Raises: ValueError, NotImplementedError """
+    """Raises: ValueError, NotImplementedError"""
     if isinstance(meta, Gt):
         if not value > meta.gt:
             raise ValueError(f"Value {value} must be > {meta.gt}")
@@ -224,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