Improve Generic list and set typing

.pre-commit-config.yaml

@@ -32,6 +32,7 @@ repos:
     hooks:
     -   id: pyupgrade
         args: [--py38-plus]
+        exclude: tests
 -   repo: https://github.com/hhatto/autopep8
     rev: v2.1.0
     hooks:

settngs/__init__.py

@@ -13,11 +13,14 @@ import warnings
 from argparse import Namespace
 from collections import defaultdict
 from collections.abc import Sequence
+from collections.abc import Set
 from typing import Any
 from typing import Callable
 from typing import cast
+from typing import Collection
 from typing import Dict
 from typing import Generic
+from typing import get_args
 from typing import NoReturn
 from typing import TYPE_CHECKING
 from typing import TypeVar
@@ -25,6 +28,8 @@ from typing import Union
 
 logger = logging.getLogger(__name__)
 
+NoneType = type(None)
+
 if sys.version_info < (3, 11):  # pragma: no cover
     from typing_extensions import NamedTuple
 else:  # pragma: no cover
@@ -41,6 +46,13 @@ if sys.version_info < (3, 9):  # pragma: no cover
         else:
             return self[:]
 
+    def get_typing_type(t: type) -> type:
+        if t.__module__ == 'builtins':
+            if t is NoneType:
+                return None
+            return getattr(typing, t.__name__.title(), t)
+        return t
+
     class BooleanOptionalAction(argparse.Action):
         def __init__(
             self,
@@ -77,7 +89,7 @@ if sys.version_info < (3, 9):  # pragma: no cover
                 metavar=metavar,
             )
 
-        def __call__(self, parser, namespace, values, option_string=None):  # dead: disable
+        def __call__(self, parser, namespace, values, option_string=None):  # pragma: no cover dead: disable
             if option_string in self.option_strings:
                 setattr(namespace, self.dest, not option_string.startswith('--no-'))
 else:  # pragma: no cover
@@ -86,8 +98,11 @@ else:  # pragma: no cover
     from argparse import BooleanOptionalAction
     removeprefix = str.removeprefix
 
+    def get_typing_type(t: type) -> type | None:
+        return None if t is NoneType else t
 
-def _isnamedtupleinstance(x: Any) -> bool:
+
+def _isnamedtupleinstance(x: Any) -> bool:  # pragma: no cover
     t = type(x)
     b = t.__bases__
 
@@ -208,57 +223,115 @@ class Setting:
             return NotImplemented
         return self.__dict__ == other.__dict__
 
-    def _guess_type(self) -> type | str | None:
+    __no_type = object()
-        if self.type is None and self.action is None:
+
-            if self.cmdline:
+    def _guess_collection(self) -> tuple[type | str | None, bool]:
-                if self.nargs in ('+', '*') or isinstance(self.nargs, int) and self.nargs > 1:
+        def get_item_type(x: Any) -> type | None:
-                    return List[str]
+            if x is None or not isinstance(x, (Set, Sequence)) or len(x) == 0:
-                return str
+                t = self._process_type()  # Specifically this is needed when using the extend action
-            else:
+                if typing.get_args(t):  # We need the item type not the type of the collection
-                if not self.cmdline and self.default is not None:
+                    return typing.get_args(t)[0]  # type: ignore[no-any-return]
-                    if not isinstance(self.default, str) and not _isnamedtupleinstance(self.default) and isinstance(self.default, Sequence) and self.default and self.default[0]:
+
+                # Return None so that we get the default
+                return None if t is None else self.__no_type  # type: ignore[return-value]
+            if isinstance(x, Set):
+                return type(next(iter(x)))
+            return type(x[0])
+
         try:
-                            return cast(type, type(self.default)[type(self.default[0])])
+            list_type = self._process_type()
+            # if the type is a generic alias than return it immediately
+            if isinstance(list_type, types_GenericAlias) and issubclass(list_type.__origin__, Collection):
+                return list_type, self.default is None
+
+            # Ensure that generic aliases work for python 3.8
+            if list_type is not None:
+                list_type = get_typing_type(list_type)
+            else:
+                list_type = get_typing_type(type(self.default))
+
+            # Default to a list if we don't know what type of collection this is
+            if list_type is None or not issubclass(list_type, Collection):
+                list_type = List
+
+            # Get the item type (int) in list[int]
+            it = get_item_type(self.default)
+            if isinstance(self.type, type):
+                it = self.type
+
+            if it is self.__no_type:
+                return self._process_type() or List[str], self.default is None
+
+            # Try to get the generic alias for this type
+            if it is not None:
+                try:
+                    ret = cast(type, list_type[it]), self.default is None  # type: ignore[index]
+                    return ret
                 except Exception:
                     ...
-                    return type(self.default)
-                return 'Any'
 
+            # Fall back to list[str] if anything fails
+            return list_type[str], self.default is None  # type: ignore[index]
+        except Exception:
+            return None, self.default is None
+
+    def _process_type(self) -> type | None:
+        if self.type is None:
+            return None
         if isinstance(self.type, type):
             return self.type
 
-        if self.type is not None:
+        return typing.get_type_hints(self.type).get('return', None)  # type: ignore[no-any-return]
-            type_hints = typing.get_type_hints(self.type)
+
-            if 'return' in type_hints:
+    def _guess_type_internal(self) -> tuple[type | str | None, bool]:
-                t: type | str = type_hints['return']
+        default_is_none = self.default is None
-                return t
+        __action_to_type = {
+            'store_true': (bool, False),
+            'store_false': (bool, False),
+            BooleanOptionalAction: (bool, default_is_none),
+            'store_const': (type(self.const), default_is_none),
+            'count': (int, default_is_none),
+            'extend': self._guess_collection(),
+            'append_const': (List[type(self.const)], default_is_none),  # type: ignore[misc]
+            'help': (None, default_is_none),
+            'version': (None, default_is_none),
+        }
+
+        # Process standard actions
+        if self.action in __action_to_type:
+            return __action_to_type[self.action]
+
+        # nargs > 1 is always a list
+        if self.nargs in ('+', '*') or isinstance(self.nargs, int) and self.nargs > 1:
+            return self._guess_collection()
+
+        # Process the type argument
+        type_type = self._process_type()
+        if type_type is not None:
+            return type_type, default_is_none
+
+        # Check if a default value was given.
         if self.default is not None:
-                if not isinstance(self.default, str) and not _isnamedtupleinstance(self.default) and isinstance(self.default, Sequence) and self.default and self.default[0]:
+            if not isinstance(self.default, str) and not _isnamedtupleinstance(self.default) and isinstance(self.default, (Set, Sequence)):
-                    try:
+                return self._guess_collection()
-                        return cast(type, type(self.default)[type(self.default[0])])
+            # The type argument will convert this if it is a string. We only get here if type is a function without type hints
-                    except Exception:
+            if not (isinstance(self.default, str) and self.type is not None):
-                        ...
+                return type(self.default), default_is_none
-                return type(self.default)
-            return 'Any'
 
-        if self.action in ('store_true', 'store_false', BooleanOptionalAction):
+        # There is no way to detemine the type from an action
-            return bool
+        if callable(self.action):
+            return 'Any', default_is_none
 
-        if self.action in ('store_const',):
+        # Finally if this is a commandline argument it will default to a string
-            return type(self.const)
+        if self.cmdline and self.type is None:
+            return str, default_is_none
+        # For file only settings it will default to Any
+        return 'Any', default_is_none
 
-        if self.action in ('count',):
+    def _guess_type(self) -> tuple[type | str | None, bool]:
-            return int
+        if self.action == 'append':
-
+            return List[self._guess_type_internal()[0]], self.default is None  # type: ignore[misc]
-        if self.action in ('append', 'extend'):
+        return self._guess_type_internal()
-            return List[str]
-
-        if self.action in ('append_const',):
-            return list  # list[type(self.const)]
-
-        if self.action in ('help', 'version'):
-            return None
-        return 'Any'
 
     def get_dest(self, prefix: str, names: Sequence[str], dest: str | None) -> tuple[str, str, str, bool]:
         setting_name = None
@@ -318,41 +391,53 @@ if TYPE_CHECKING:
     ns = Namespace | TypedNS | Config[T] | None
 
 
-def generate_ns(definitions: Definitions) -> tuple[str, str]:
+def _type_to_string(t: type | str) -> tuple[str, str]:
-    initial_imports = ['from __future__ import annotations', '', 'import settngs']
-    imports: Sequence[str] | set[str]
-    imports = set()
-
-    attributes = []
-    for group in definitions.values():
-        for setting in group.v.values():
-            t = setting._guess_type()
-            if t is None:
-                continue
-            # Default to any
     type_name = 'Any'
-
+    import_needed = ''
     # Take a string as is
     if isinstance(t, str):
         type_name = t
     # Handle generic aliases eg dict[str, str] instead of dict
     elif isinstance(t, types_GenericAlias):
+        if not get_args(t):
+            t = t.__origin__.__name__
         type_name = str(t)
     # Handle standard type objects
     elif isinstance(t, type):
         type_name = t.__name__
         # Builtin types don't need an import
         if t.__module__ != 'builtins':
-                    imports.add(f'import {t.__module__}')
+            import_needed = f'import {t.__module__}'
             # Use the full imported name
             type_name = t.__module__ + '.' + type_name
 
     # Expand Any to typing.Any
     if type_name == 'Any':
         type_name = 'typing.Any'
+    return type_name, import_needed
 
+
+def generate_ns(definitions: Definitions) -> tuple[str, str]:
+    initial_imports = ['from __future__ import annotations', '', 'import settngs']
+    imports: Sequence[str] | set[str]
+    imports = set()
+
+    attributes = []
+    used_attributes: set[str] = set()
+    for group in definitions.values():
+        for setting in group.v.values():
+            t, noneable = setting._guess_type()
+            if t is None:
+                continue
+            type_name, import_needed = _type_to_string(t)
+            imports.add(import_needed)
+
+            if noneable and type_name not in ('typing.Any', 'None'):
+                attribute = f'    {setting.internal_name}: {type_name} | None'
+            else:
                 attribute = f'    {setting.internal_name}: {type_name}'
-            if attribute not in attributes:
+            if setting.internal_name not in used_attributes:
+                used_attributes.add(setting.internal_name)
                 attributes.append(attribute)
         # Add a blank line between groups
         if attributes and attributes[-1] != '':
@@ -369,7 +454,7 @@ def generate_ns(definitions: Definitions) -> tuple[str, str]:
         initial_imports.append('import typing')
 
     # Remove the possible duplicate typing import
-    imports = sorted(list(imports - {'import typing'}))
+    imports = sorted(imports - {'import typing', ''})
 
     # Merge the imports the ns class definition and the attributes
     return '\n'.join(initial_imports + imports), ns + '\n'.join(attributes)
@@ -384,34 +469,20 @@ def generate_dict(definitions: Definitions) -> tuple[str, str]:
     classes = []
     for group_name, group in definitions.items():
         attributes = []
+        used_attributes: set[str] = set()
         for setting in group.v.values():
-            t = setting._guess_type()
+            t, no_default = setting._guess_type()
             if t is None:
                 continue
-            # Default to any
+            type_name, import_needed = _type_to_string(t)
-            type_name = 'Any'
+            imports.add(import_needed)
-
-            # Take a string as is
-            if isinstance(t, str):
-                type_name = t
-            # Handle generic aliases eg dict[str, str] instead of dict
-            elif isinstance(t, types_GenericAlias):
-                type_name = str(t)
-            # Handle standard type objects
-            elif isinstance(t, type):
-                type_name = t.__name__
-                # Builtin types don't need an import
-                if t.__module__ != 'builtins':
-                    imports.add(f'import {t.__module__}')
-                    # Use the full imported name
-                    type_name = t.__module__ + '.' + type_name
-
-            # Expand Any to typing.Any
-            if type_name == 'Any':
-                type_name = 'typing.Any'
 
+            if no_default and type_name not in ('typing.Any', 'None'):
+                attribute = f'    {setting.dest}: {type_name} | None'
+            else:
                 attribute = f'    {setting.dest}: {type_name}'
-            if attribute not in attributes:
+            if setting.dest not in used_attributes:
+                used_attributes.add(setting.dest)
                 attributes.append(attribute)
         if not attributes or all(x == '' for x in attributes):
             attributes = ['    ...']
@@ -421,7 +492,7 @@ def generate_dict(definitions: Definitions) -> tuple[str, str]:
         )
 
     # Remove the possible duplicate typing import
-    imports = sorted(list(imports - {'import typing'}))
+    imports = sorted(list(imports - {'import typing', ''}))
 
     if groups_are_identifiers:
         ns = '\nclass SettngsDict(typing.TypedDict):\n'

tests/settngs_test.py

@@ -19,6 +19,7 @@ from testing.settngs import success
 
 if sys.version_info >= (3, 10):  # pragma: no cover
     List = list
+    Set = set
     help_output = '''\
 usage: __main__.py [-h] [TEST ...]
 
@@ -30,6 +31,7 @@ options:
 '''
 elif sys.version_info < (3, 9):  # pragma: no cover
     from typing import List
+    from typing import Set
     help_output = '''\
 usage: __main__.py [-h] [TEST [TEST ...]]
 
@@ -42,6 +44,7 @@ optional arguments:
 
 else:  # pragma: no cover
     List = list
+    Set = set
     help_output = '''\
 usage: __main__.py [-h] [TEST ...]
 
@@ -618,6 +621,18 @@ def _typed_function(something: str) -> test_type:  # pragma: no cover
     return test_type()
 
 
+def _typed_list_generic_function(something: test_type) -> List[test_type]:  # pragma: no cover
+    return [test_type()]
+
+
+def _typed_list_function() -> List:   # type: ignore[type-arg] # pragma: no cover
+    return []
+
+
+def _typed_set_function() -> Set:  # type: ignore[type-arg] # pragma: no cover
+    return set()
+
+
 def _untyped_function(something):
     ...
 
@@ -644,37 +659,51 @@ class _customAction(argparse.Action):  # pragma: no cover
             help=help,
         )
 
-    def __call__(self, parser, namespace, values, option_string=None):
+    def __call__(self, parser, namespace, values, option_string=None):  # pragma: no cover
         setattr(namespace, self.dest, 'Something')
 
 
 types = (
-    (0, settngs.Setting('-t', '--test'), str),
+    (0, settngs.Setting('-t', '--test'), str, True),
-    (1, settngs.Setting('-t', '--test', cmdline=False), 'Any'),
+    (1, settngs.Setting('-t', '--test', cmdline=False), 'Any', True),
-    (2, settngs.Setting('-t', '--test', default=1, file=True, cmdline=False), int),
+    (2, settngs.Setting('-t', '--test', default=1, file=True, cmdline=False), int, False),
-    (3, settngs.Setting('-t', '--test', action='count'), int),
+    (3, settngs.Setting('-t', '--test', default='test'), str, False),
-    (4, settngs.Setting('-t', '--test', action='append'), List[str]),
+    (4, settngs.Setting('-t', '--test', default='test', file=True, cmdline=False), str, False),
-    (5, settngs.Setting('-t', '--test', action='extend'), List[str]),
+    (5, settngs.Setting('-t', '--test', action='count'), int, True),
-    (6, settngs.Setting('-t', '--test', nargs='+'), List[str]),
+    (6, settngs.Setting('-t', '--test', action='append'), List[str], True),
-    (7, settngs.Setting('-t', '--test', action='store_const', const=1), int),
+    (7, settngs.Setting('-t', '--test', action='extend'), List[str], True),
-    (8, settngs.Setting('-t', '--test', action='append_const', const=1), list),
+    (8, settngs.Setting('-t', '--test', nargs='+'), List[str], True),
-    (9, settngs.Setting('-t', '--test', action='store_true'), bool),
+    (9, settngs.Setting('-t', '--test', action='store_const', const=1), int, True),
-    (10, settngs.Setting('-t', '--test', action='store_false'), bool),
+    (10, settngs.Setting('-t', '--test', action='append_const', const=1), List[int], True),
-    (11, settngs.Setting('-t', '--test', action=settngs.BooleanOptionalAction), bool),
+    (11, settngs.Setting('-t', '--test', action='store_true'), bool, False),
-    (12, settngs.Setting('-t', '--test', action=_customAction), 'Any'),
+    (12, settngs.Setting('-t', '--test', action='store_false'), bool, False),
-    (13, settngs.Setting('-t', '--test', action='help'), None),
+    (13, settngs.Setting('-t', '--test', action=settngs.BooleanOptionalAction), bool, True),
-    (14, settngs.Setting('-t', '--test', action='version'), None),
+    (14, settngs.Setting('-t', '--test', action=_customAction), 'Any', True),
-    (15, settngs.Setting('-t', '--test', type=int), int),
+    (15, settngs.Setting('-t', '--test', action='help'), None, True),
-    (16, settngs.Setting('-t', '--test', type=_typed_function), test_type),
+    (16, settngs.Setting('-t', '--test', action='version'), None, True),
-    (17, settngs.Setting('-t', '--test', type=_untyped_function, default=1), int),
+    (17, settngs.Setting('-t', '--test', type=int), int, True),
-    (18, settngs.Setting('-t', '--test', type=_untyped_function), 'Any'),
+    (18, settngs.Setting('-t', '--test', type=int, nargs='+'), List[int], True),
+    (19, settngs.Setting('-t', '--test', type=_typed_function), test_type, True),
+    (20, settngs.Setting('-t', '--test', type=_untyped_function, default=1), int, False),
+    (21, settngs.Setting('-t', '--test', type=_untyped_function, default=[1]), List[int], False),
+    (22, settngs.Setting('-t', '--test', type=_untyped_function), 'Any', True),
+    (23, settngs.Setting('-t', '--test', type=_untyped_function, default={1}), Set[int], False),
+    (24, settngs.Setting('-t', '--test', action='append', type=int), List[int], True),
+    (25, settngs.Setting('-t', '--test', action='extend', type=int, nargs=2), List[int], True),
+    (26, settngs.Setting('-t', '--test', action='append', type=int, nargs=2), List[List[int]], True),
+    (27, settngs.Setting('-t', '--test', action='extend', nargs='+'), List[str], True),
+    (28, settngs.Setting('-t', '--test', action='extend', type=_typed_list_generic_function), List[test_type], True),
+    (29, settngs.Setting('-t', '--test', action='extend', type=_typed_list_function), List, True),
+    (30, settngs.Setting('-t', '--test', action='extend', type=_typed_set_function), Set, True),
 )
 
 
-@pytest.mark.parametrize('num,setting,typ', types)
+@pytest.mark.parametrize('num,setting,typ,noneable_expected', types)
-def test_guess_type(num, setting, typ):
+def test_guess_type(num, setting, typ, noneable_expected):
-    guessed_type = setting._guess_type()
+    x = setting._guess_type()
+    guessed_type, noneable = x
     assert guessed_type == typ
+    assert noneable == noneable_expected
 
 
 expected_src = '''from __future__ import annotations
@@ -694,25 +723,37 @@ class SettngsNS(settngs.TypedNS):
     ...
 '''
 settings = (
-    (0, lambda parser: parser.add_setting('-t', '--test'), expected_src.format(extra_imports='', typ='str')),
+    (0, lambda parser: parser.add_setting('-t', '--test'), expected_src.format(extra_imports='', typ='str | None')),
     (1, lambda parser: parser.add_setting('-t', '--test', cmdline=False), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
     (2, lambda parser: parser.add_setting('-t', '--test', default=1, file=True, cmdline=False), expected_src.format(extra_imports='', typ='int')),
-    (3, lambda parser: parser.add_setting('-t', '--test', action='count'), expected_src.format(extra_imports='', typ='int')),
+    (3, lambda parser: parser.add_setting('-t', '--test', default='test'), expected_src.format(extra_imports='', typ='str')),
-    (4, lambda parser: parser.add_setting('-t', '--test', action='append'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ='typing.List[str]' if sys.version_info < (3, 9) else 'list[str]')),
+    (4, lambda parser: parser.add_setting('-t', '--test', default='test', file=True, cmdline=False), expected_src.format(extra_imports='', typ='str')),
-    (5, lambda parser: parser.add_setting('-t', '--test', action='extend'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ='typing.List[str]' if sys.version_info < (3, 9) else 'list[str]')),
+    (5, lambda parser: parser.add_setting('-t', '--test', action='count'), expected_src.format(extra_imports='', typ='int | None')),
-    (6, lambda parser: parser.add_setting('-t', '--test', nargs='+'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ='typing.List[str]' if sys.version_info < (3, 9) else 'list[str]')),
+    (6, lambda parser: parser.add_setting('-t', '--test', action='append'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[str]} | None')),
-    (7, lambda parser: parser.add_setting('-t', '--test', action='store_const', const=1), expected_src.format(extra_imports='', typ='int')),
+    (7, lambda parser: parser.add_setting('-t', '--test', action='extend'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[str]} | None')),
-    (8, lambda parser: parser.add_setting('-t', '--test', action='append_const', const=1), expected_src.format(extra_imports='', typ='list')),
+    (8, lambda parser: parser.add_setting('-t', '--test', nargs='+'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[str]} | None')),
-    (9, lambda parser: parser.add_setting('-t', '--test', action='store_true'), expected_src.format(extra_imports='', typ='bool')),
+    (9, lambda parser: parser.add_setting('-t', '--test', action='store_const', const=1), expected_src.format(extra_imports='', typ='int | None')),
-    (10, lambda parser: parser.add_setting('-t', '--test', action='store_false'), expected_src.format(extra_imports='', typ='bool')),
+    (10, lambda parser: parser.add_setting('-t', '--test', action='append_const', const=1), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[int]} | None')),
-    (11, lambda parser: parser.add_setting('-t', '--test', action=settngs.BooleanOptionalAction), expected_src.format(extra_imports='', typ='bool')),
+    (11, lambda parser: parser.add_setting('-t', '--test', action='store_true'), expected_src.format(extra_imports='', typ='bool')),
-    (12, lambda parser: parser.add_setting('-t', '--test', action=_customAction), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
+    (12, lambda parser: parser.add_setting('-t', '--test', action='store_false'), expected_src.format(extra_imports='', typ='bool')),
-    (13, lambda parser: parser.add_setting('-t', '--test', action='help'), no_type_expected_src),
+    (13, lambda parser: parser.add_setting('-t', '--test', action=settngs.BooleanOptionalAction), expected_src.format(extra_imports='', typ='bool | None')),
-    (14, lambda parser: parser.add_setting('-t', '--test', action='version'), no_type_expected_src),
+    (14, lambda parser: parser.add_setting('-t', '--test', action=_customAction), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
-    (15, lambda parser: parser.add_setting('-t', '--test', type=int), expected_src.format(extra_imports='', typ='int')),
+    (15, lambda parser: parser.add_setting('-t', '--test', action='help'), no_type_expected_src),
-    (16, lambda parser: parser.add_setting('-t', '--test', type=_typed_function), expected_src.format(extra_imports='import tests.settngs_test\n', typ='tests.settngs_test.test_type')),
+    (16, lambda parser: parser.add_setting('-t', '--test', action='version'), no_type_expected_src),
-    (17, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=1), expected_src.format(extra_imports='', typ='int')),
+    (17, lambda parser: parser.add_setting('-t', '--test', type=int), expected_src.format(extra_imports='', typ='int | None')),
-    (18, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
+    (18, lambda parser: parser.add_setting('-t', '--test', type=int, nargs='+'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[int]} | None')),
+    (19, lambda parser: parser.add_setting('-t', '--test', type=_typed_function), expected_src.format(extra_imports='import tests.settngs_test\n', typ='tests.settngs_test.test_type | None')),
+    (20, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=1), expected_src.format(extra_imports='', typ='int')),
+    (21, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=[1]), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[int]}')),
+    (22, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
+    (23, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default={1}), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{Set[int]}')),
+    (24, lambda parser: parser.add_setting('-t', '--test', action='append', type=int), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[int]} | None')),
+    (25, lambda parser: parser.add_setting('-t', '--test', action='extend', type=int, nargs=2), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[int]} | None')),
+    (26, lambda parser: parser.add_setting('-t', '--test', action='append', type=int, nargs=2), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[List[int]]} | None')),
+    (27, lambda parser: parser.add_setting('-t', '--test', action='extend', nargs='+'), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[str]} | None')),
+    (28, lambda parser: parser.add_setting('-t', '--test', action='extend', type=_typed_list_generic_function), expected_src.format(extra_imports='import typing\n' if sys.version_info < (3, 9) else '', typ=f'{List[test_type]} | None')),
+    (29, lambda parser: parser.add_setting('-t', '--test', action='extend', type=_typed_list_function), expected_src.format(extra_imports='', typ=f'{settngs._type_to_string(List)[0]} | None')),
+    (30, lambda parser: parser.add_setting('-t', '--test', action='extend', type=_typed_set_function), expected_src.format(extra_imports='', typ=f'{settngs._type_to_string(Set)[0]} | None')),
 )
 
 
@@ -753,25 +794,37 @@ class SettngsDict(typing.TypedDict):
     test: test
 '''
 settings_dict = (
-    (0, lambda parser: parser.add_setting('-t', '--test'), expected_src_dict.format(extra_imports='', typ='str')),
+    (0, lambda parser: parser.add_setting('-t', '--test'), expected_src_dict.format(extra_imports='', typ='str | None')),
     (1, lambda parser: parser.add_setting('-t', '--test', cmdline=False), expected_src_dict.format(extra_imports='', typ='typing.Any')),
     (2, lambda parser: parser.add_setting('-t', '--test', default=1, file=True, cmdline=False), expected_src_dict.format(extra_imports='', typ='int')),
-    (3, lambda parser: parser.add_setting('-t', '--test', action='count'), expected_src_dict.format(extra_imports='', typ='int')),
+    (3, lambda parser: parser.add_setting('-t', '--test', default='test'), expected_src_dict.format(extra_imports='', typ='str')),
-    (4, lambda parser: parser.add_setting('-t', '--test', action='append'), expected_src_dict.format(extra_imports='' if sys.version_info < (3, 9) else '', typ='typing.List[str]' if sys.version_info < (3, 9) else 'list[str]')),
+    (4, lambda parser: parser.add_setting('-t', '--test', default='test', file=True, cmdline=False), expected_src_dict.format(extra_imports='', typ='str')),
-    (5, lambda parser: parser.add_setting('-t', '--test', action='extend'), expected_src_dict.format(extra_imports='' if sys.version_info < (3, 9) else '', typ='typing.List[str]' if sys.version_info < (3, 9) else 'list[str]')),
+    (5, lambda parser: parser.add_setting('-t', '--test', action='count'), expected_src_dict.format(extra_imports='', typ='int | None')),
-    (6, lambda parser: parser.add_setting('-t', '--test', nargs='+'), expected_src_dict.format(extra_imports='' if sys.version_info < (3, 9) else '', typ='typing.List[str]' if sys.version_info < (3, 9) else 'list[str]')),
+    (6, lambda parser: parser.add_setting('-t', '--test', action='append'), expected_src_dict.format(extra_imports='', typ=f'{List[str]} | None')),
-    (7, lambda parser: parser.add_setting('-t', '--test', action='store_const', const=1), expected_src_dict.format(extra_imports='', typ='int')),
+    (7, lambda parser: parser.add_setting('-t', '--test', action='extend'), expected_src_dict.format(extra_imports='', typ=f'{List[str]} | None')),
-    (8, lambda parser: parser.add_setting('-t', '--test', action='append_const', const=1), expected_src_dict.format(extra_imports='', typ='list')),
+    (8, lambda parser: parser.add_setting('-t', '--test', nargs='+'), expected_src_dict.format(extra_imports='', typ=f'{List[str]} | None')),
-    (9, lambda parser: parser.add_setting('-t', '--test', action='store_true'), expected_src_dict.format(extra_imports='', typ='bool')),
+    (9, lambda parser: parser.add_setting('-t', '--test', action='store_const', const=1), expected_src_dict.format(extra_imports='', typ='int | None')),
-    (10, lambda parser: parser.add_setting('-t', '--test', action='store_false'), expected_src_dict.format(extra_imports='', typ='bool')),
+    (10, lambda parser: parser.add_setting('-t', '--test', action='append_const', const=1), expected_src_dict.format(extra_imports='', typ=f'{List[int]} | None')),
-    (11, lambda parser: parser.add_setting('-t', '--test', action=settngs.BooleanOptionalAction), expected_src_dict.format(extra_imports='', typ='bool')),
+    (11, lambda parser: parser.add_setting('-t', '--test', action='store_true'), expected_src_dict.format(extra_imports='', typ='bool')),
-    (12, lambda parser: parser.add_setting('-t', '--test', action=_customAction), expected_src_dict.format(extra_imports='', typ='typing.Any')),
+    (12, lambda parser: parser.add_setting('-t', '--test', action='store_false'), expected_src_dict.format(extra_imports='', typ='bool')),
-    (13, lambda parser: parser.add_setting('-t', '--test', action='help'), no_type_expected_src_dict),
+    (13, lambda parser: parser.add_setting('-t', '--test', action=settngs.BooleanOptionalAction), expected_src_dict.format(extra_imports='', typ='bool | None')),
-    (14, lambda parser: parser.add_setting('-t', '--test', action='version'), no_type_expected_src_dict),
+    (14, lambda parser: parser.add_setting('-t', '--test', action=_customAction), expected_src_dict.format(extra_imports='', typ='typing.Any')),
-    (15, lambda parser: parser.add_setting('-t', '--test', type=int), expected_src_dict.format(extra_imports='', typ='int')),
+    (15, lambda parser: parser.add_setting('-t', '--test', action='help'), no_type_expected_src_dict),
-    (16, lambda parser: parser.add_setting('-t', '--test', type=_typed_function), expected_src_dict.format(extra_imports='import tests.settngs_test\n', typ='tests.settngs_test.test_type')),
+    (16, lambda parser: parser.add_setting('-t', '--test', action='version'), no_type_expected_src_dict),
-    (17, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=1), expected_src_dict.format(extra_imports='', typ='int')),
+    (17, lambda parser: parser.add_setting('-t', '--test', type=int), expected_src_dict.format(extra_imports='', typ='int | None')),
-    (18, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function), expected_src_dict.format(extra_imports='', typ='typing.Any')),
+    (18, lambda parser: parser.add_setting('-t', '--test', type=int, nargs='+'), expected_src_dict.format(extra_imports='', typ=f'{List[int]} | None')),
+    (19, lambda parser: parser.add_setting('-t', '--test', type=_typed_function), expected_src_dict.format(extra_imports='import tests.settngs_test\n', typ=f'{test_type.__module__}.{test_type.__name__} | None')),
+    (20, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=1), expected_src_dict.format(extra_imports='', typ='int')),
+    (21, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=[1]), expected_src_dict.format(extra_imports='', typ=f'{List[int]}')),
+    (22, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function), expected_src_dict.format(extra_imports='', typ='typing.Any')),
+    (23, lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default={1}), expected_src_dict.format(extra_imports='', typ=f'{Set[int]}')),
+    (24, lambda parser: parser.add_setting('-t', '--test', action='append', type=int), expected_src_dict.format(extra_imports='', typ=f'{List[int]} | None')),
+    (25, lambda parser: parser.add_setting('-t', '--test', action='extend', type=int, nargs=2), expected_src_dict.format(extra_imports='', typ=f'{List[int]} | None')),
+    (26, lambda parser: parser.add_setting('-t', '--test', action='append', type=int, nargs=2), expected_src_dict.format(extra_imports='', typ=f'{List[List[int]]} | None')),
+    (27, lambda parser: parser.add_setting('-t', '--test', action='extend', nargs='+'), expected_src_dict.format(extra_imports='', typ=f'{List[str]} | None')),
+    (28, lambda parser: parser.add_setting('-t', '--test', action='extend', type=_typed_list_generic_function), expected_src_dict.format(extra_imports='', typ=f'{List[test_type]} | None')),
+    (29, lambda parser: parser.add_setting('-t', '--test', action='extend', type=_typed_list_function), expected_src_dict.format(extra_imports='', typ=f'{settngs._type_to_string(List)[0]} | None')),
+    (30, lambda parser: parser.add_setting('-t', '--test', action='extend', type=_typed_set_function), expected_src_dict.format(extra_imports='', typ=f'{settngs._type_to_string(Set)[0]} | None')),
 )