[pre-commit.ci] pre-commit autoupdate

updates:
- [github.com/asottile/pyupgrade: v3.15.2 → v3.16.0](https://github.com/asottile/pyupgrade/compare/v3.15.2...v3.16.0)
- [github.com/hhatto/autopep8: v2.2.0 → v2.3.1](https://github.com/hhatto/autopep8/compare/v2.2.0...v2.3.1)
- [github.com/PyCQA/flake8: 7.0.0 → 7.1.0](https://github.com/PyCQA/flake8/compare/7.0.0...7.1.0)

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v4.6.0
     hooks:
     -   id: trailing-whitespace
     -   id: end-of-file-fixer
@@ -10,38 +10,39 @@ repos:
     -   id: name-tests-test
     -   id: requirements-txt-fixer
 -   repo: https://github.com/asottile/setup-cfg-fmt
-    rev: v2.3.0
+    rev: v2.5.0
     hooks:
     -   id: setup-cfg-fmt
 -   repo: https://github.com/asottile/reorder-python-imports
-    rev: v3.9.0
+    rev: v3.13.0
     hooks:
     -   id: reorder-python-imports
         args: [--py38-plus, --add-import, 'from __future__ import annotations']
 -   repo: https://github.com/asottile/add-trailing-comma
-    rev: v2.4.0
+    rev: v3.1.0
     hooks:
     -   id: add-trailing-comma
         args: [--py36-plus]
 -   repo: https://github.com/asottile/dead
-    rev: v1.5.1
+    rev: v1.5.2
     hooks:
     -   id: dead
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v3.4.0
+    rev: v3.16.0
     hooks:
     -   id: pyupgrade
         args: [--py38-plus]
--   repo: https://github.com/pre-commit/mirrors-autopep8
+        exclude: tests
-    rev: v2.0.2
+-   repo: https://github.com/hhatto/autopep8
+    rev: v2.3.1
     hooks:
     -   id: autopep8
 -   repo: https://github.com/PyCQA/flake8
-    rev: 6.0.0
+    rev: 7.1.0
     hooks:
     -   id: flake8
-        additional_dependencies: [flake8-encodings, flake8-warnings, flake8-builtins, flake8-length, flake8-print]
+        additional_dependencies: [flake8-encodings, flake8-warnings, flake8-builtins, flake8-print]
 -   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.3.0
+    rev: v1.10.0
     hooks:
     -   id: mypy

README.md

@@ -29,14 +29,14 @@ $ python -m settngs
 Hello lordwelch
 $ python -m settngs -v
 Hello lordwelch
-merged_namespace.values.example_verbose=True
+merged_namespace.values.Example_Group__verbose=True
 $ python -m settngs -v -s
 Hello lordwelch
 Successfully saved settings to settings.json
-merged_namespace.values.example_verbose=True
+merged_namespace.values.Example_Group__verbose=True
 $ python -m settngs
 Hello lordwelch
-merged_namespace.values.example_verbose=True
+merged_namespace.values.Example_Group__verbose=True
 $ cat >settings.json << EOF
 {
   "example": {
@@ -64,7 +64,7 @@ Hello world
 settngs.json at the end:
 ```json
 {
-  "example": {
+  "Example Group": {
     "hello": "world",
     "verbose": false
   },

settngs/__init__.py

@@ -1,27 +1,37 @@
 from __future__ import annotations
 
 import argparse
+import copy
+import inspect
 import json
 import logging
 import pathlib
 import re
 import sys
 import typing
+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 Literal
+from typing import get_args
+from typing import Mapping
 from typing import NoReturn
+from typing import Tuple
 from typing import TYPE_CHECKING
 from typing import TypeVar
 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
@@ -38,6 +48,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,
@@ -74,7 +91,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
@@ -83,6 +100,23 @@ 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:  # pragma: no cover
+    t = type(x)
+    b = t.__bases__
+
+    if len(b) != 1 or b[0] != tuple:
+        return False
+
+    f = getattr(t, '_fields', None)
+    if not isinstance(f, tuple):
+        return False
+
+    return all(isinstance(n, str) for n in f)
+
 
 class Setting:
     def __init__(
@@ -107,6 +141,9 @@ class Setting:
         exclusive: bool = False,
     ):
         """
+        Attributes:
+        setting_name:     This is the name used to retrieve this Setting object from a `Config` Definitions dictionary.
+                          This only differs from dest when a custom dest is given
 
         Args:
             *names:       Passed directly to argparse
@@ -119,7 +156,8 @@ class Setting:
             required:     Passed directly to argparse
             help:         Passed directly to argparse
             metavar:      Passed directly to argparse, defaults to `dest` upper-cased
-            dest:         This is the name used to retrieve the value from a `Config` object as a dictionary
+            dest:         This is the name used to retrieve the value from a `Config` object as a dictionary.
+                          Default to `setting_name`.
             display_name: This is not used by settngs. This is a human-readable name to be used when generating a GUI.
                           Defaults to `dest`.
             cmdline:      If this setting can be set via the commandline
@@ -133,18 +171,18 @@ class Setting:
             raise ValueError('names must be specified')
         # We prefix the destination name used by argparse so that there are no conflicts
         # Argument names will still cause an exception if there is a conflict e.g. if '-f' is defined twice
-        self.internal_name, dest, flag = self.get_dest(group, names, dest)
+        self.internal_name, self.setting_name, dest, self.flag = self.get_dest(group, names, dest)
         args: Sequence[str] = names
 
         # We then also set the metavar so that '--config' in the group runtime shows as 'CONFIG' instead of 'RUNTIME_CONFIG'
-        if not metavar and action not in ('store_true', 'store_false', 'count'):
+        if not metavar and action not in ('store_true', 'store_false', 'count', 'help', 'version'):
+            if not callable(action) or 'metavar' in inspect.signature(action).parameters.keys():
                 metavar = dest.upper()
 
         # If we are not a flag, no '--' or '-' in front
-        # we prefix the first name with the group as argparse sets dest to args[0]
+        # we use internal_name as argparse sets dest to args[0]
-        # I believe internal name may be able to be used here
+        if not self.flag:
-        if not flag:
+            args = tuple((self.internal_name, *names[1:]))
-            args = tuple((f'{group}_{names[0]}'.lstrip('_'), *names[1:]))
 
         self.action = action
         self.nargs = nargs
@@ -173,7 +211,7 @@ class Setting:
             'required': required,
             'help': help,
             'metavar': metavar,
-            'dest': self.internal_name if flag else None,
+            'dest': self.internal_name if self.flag else None,
         }
 
     def __str__(self) -> str:  # pragma: no cover
@@ -187,68 +225,140 @@ class Setting:
             return NotImplemented
         return self.__dict__ == other.__dict__
 
-    def _guess_type(self) -> type | Literal['Any'] | None:
+    __no_type = object()
-        if self.type is None and self.action is None:
-            if self.cmdline:
-                if self.nargs in ('+', '*') or isinstance(self.nargs, int) and self.nargs > 1:
-                    return List[str]
-                return str
-            else:
-                if not self.cmdline and self.default is not None:
-                    return type(self.default)
-                return 'Any'
 
+    def _guess_collection(self) -> tuple[type | str | None, bool]:
+        def get_item_type(x: Any) -> type | None:
+            if x is None or not isinstance(x, (Set, Sequence)) or len(x) == 0:
+                t = self._process_type()  # Specifically this is needed when using the extend action
+                if typing.get_args(t):  # We need the item type not the type of the collection
+                    return typing.get_args(t)[0]  # type: ignore[no-any-return]
+
+                # 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:
+            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:
+                    ...
+
+            # 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 and isinstance(type_hints['return'], type):
+    def _guess_type_internal(self) -> tuple[type | str | None, bool]:
-                return type_hints['return']
+        default_is_none = self.default is None
+        __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:
-                return type(self.default)
+            if not isinstance(self.default, str) and not _isnamedtupleinstance(self.default) and isinstance(self.default, (Set, Sequence)):
-            return 'Any'
+                return self._guess_collection()
+            # The type argument will convert this if it is a string. We only get here if type is a function without type hints
+            if not (isinstance(self.default, str) and self.type is not None):
+                return type(self.default), default_is_none
 
-        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]
+        return self._guess_type_internal()
 
-        if self.action in ('append', 'extend'):
+    def get_dest(self, prefix: str, names: Sequence[str], dest: str | None) -> tuple[str, str, str, bool]:
-            return List[str]
+        setting_name = None
-
-        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, bool]:
-        dest_name = None
         flag = False
 
+        prefix = sanitize_name(prefix)
         for n in names:
             if n.startswith('--'):
                 flag = True
-                dest_name = sanitize_name(n)
+                setting_name = sanitize_name(n)
                 break
             if n.startswith('-'):
                 flag = True
 
-        if dest_name is None:
+        if setting_name is None:
-            dest_name = names[0]
+            setting_name = names[0]
         if dest:
             dest_name = dest
+        else:
+            dest_name = setting_name
         if not dest_name.isidentifier():
             raise Exception(f'Cannot use {dest_name} in a namespace')
 
-        internal_name = f'{prefix}_{dest_name}'.lstrip('_')
+        internal_name = f'{prefix}__{dest_name}'.lstrip('_')
-        return internal_name, dest_name, flag
+        return internal_name, setting_name, dest_name, flag
 
     def filter_argparse_kwargs(self) -> dict[str, Any]:
         return {k: v for k, v in self.argparse_kwargs.items() if v is not None}
@@ -257,7 +367,7 @@ class Setting:
         return self.argparse_args, self.filter_argparse_kwargs()
 
 
-class TypedNS:
+class TypedNS():
     def __init__(self) -> None:
         raise TypeError('TypedNS cannot be instantiated')
 
@@ -267,7 +377,8 @@ class Group(NamedTuple):
     v: dict[str, Setting]
 
 
-Values = Dict[str, Dict[str, Any]]
+Values = Mapping[str, Any]
+_values = Dict[str, Dict[str, Any]]
 Definitions = Dict[str, Group]
 
 T = TypeVar('T', bound=Union[Values, Namespace, TypedNS])
@@ -280,40 +391,124 @@ class Config(NamedTuple, Generic[T]):
 
 if TYPE_CHECKING:
     ArgParser = Union[argparse._MutuallyExclusiveGroup, argparse._ArgumentGroup, argparse.ArgumentParser]
-    ns = Namespace | TypedNS | Config[T] | None
+    ns = Union[TypedNS, Config[T], None]
 
 
-def generate_ns(definitions: Definitions) -> str:
+def _type_to_string(t: type | str) -> tuple[str, str]:
-    imports = ['from __future__ import annotations', 'import typing', 'import settngs']
-    ns = 'class settngs_namespace(settngs.TypedNS):\n'
-    types = []
-    for group_name, group in definitions.items():
-        for setting_name, setting in group.v.items():
-            t = setting._guess_type()
-            if t is None:
-                continue
     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.append(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
 
-            types.append(f'    {setting.internal_name}: {type_name}')
-        if types and types[-1] != '':
-            types.append('')
 
-    if not types or all(x == '' for x in types):
+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 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] != '':
+            attributes.append('')
+
+    ns = 'class SettngsNS(settngs.TypedNS):\n'
+    # Add a '...' expression if there are no attributes
+    if not attributes or all(x == '' for x in attributes):
         ns += '    ...\n'
-        types = ['']
+        attributes = ['']
 
-    return '\n'.join(imports) + '\n\n' + ns + '\n'.join(types)
+    # Add the tying import before extra imports
+    if 'typing.' in '\n'.join(attributes):
+        initial_imports.append('import typing')
+
+    # Remove the possible duplicate typing import
+    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)
+
+
+def generate_dict(definitions: Definitions) -> tuple[str, str]:
+    initial_imports = ['from __future__ import annotations', '', 'import typing']
+    imports: Sequence[str] | set[str]
+    imports = set()
+
+    groups_are_identifiers = all(n.isidentifier() for n in definitions.keys())
+    classes = []
+    for group_name, group in definitions.items():
+        attributes = []
+        used_attributes: set[str] = set()
+        for setting in group.v.values():
+            t, no_default = setting._guess_type()
+            if t is None:
+                continue
+            type_name, import_needed = _type_to_string(t)
+            imports.add(import_needed)
+
+            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 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 = ['    ...']
+        classes.append(
+            f'class {sanitize_name(group_name)}(typing.TypedDict):\n'
+            + '\n'.join(attributes) + '\n\n',
+        )
+
+    # Remove the possible duplicate typing import
+    imports = sorted(list(imports - {'import typing', ''}))
+
+    if groups_are_identifiers:
+        ns = '\nclass SettngsDict(typing.TypedDict):\n'
+        ns += '\n'.join(f'    {n}: {sanitize_name(n)}' for n in definitions.keys())
+    else:
+        ns = '\nSettngsDict = typing.TypedDict(\n'
+        ns += "    'SettngsDict', {\n"
+        for n in definitions.keys():
+            ns += f'        {n!r}: {sanitize_name(n)},\n'
+        ns += '    },\n'
+        ns += ')\n'
+    # Merge the imports the ns class definition and the attributes
+    return '\n'.join(initial_imports + imports), '\n'.join(classes) + ns + '\n'
 
 
 def sanitize_name(name: str) -> str:
@@ -354,11 +549,34 @@ def get_options(config: Config[T], group: str) -> dict[str, Any]:
                 if name in internal_names:
                     values[internal_names[name].dest] = value
                 else:
-                    values[removeprefix(name, f'{group}_')] = value
+                    values[removeprefix(name, f'{group}').lstrip('_')] = value
-
     return values
 
 
+def get_groups(values: Values | Namespace | TypedNS) -> list[str]:
+    if isinstance(values, dict):
+        return [x[0] for x in values.items() if isinstance(x[1], dict)]
+    if isinstance(values, Namespace):
+        groups = set()
+        for name in values.__dict__:
+            if '__' in name:
+                group, _, _ = name.partition('__')
+                groups.add(group.replace('_', ' '))
+            else:
+                groups.add('')
+        return list(groups)
+    return []
+
+
+def _get_internal_definitions(config: Config[T], persistent: bool) -> Definitions:
+    definitions = copy.deepcopy(dict(config.definitions))
+    if persistent:
+        for group_name in get_groups(config.values):
+            if group_name not in definitions:
+                definitions[group_name] = Group(True, {})
+    return defaultdict(lambda: Group(False, {}), definitions)
+
+
 def normalize_config(
     config: Config[T],
     file: bool = False,
@@ -376,33 +594,35 @@ def normalize_config(
         file: Include file options
         cmdline: Include cmdline options
         default: Include default values in the returned Config object
-        persistent: Include unknown keys in persistent groups
+        persistent: Include unknown keys in persistent groups and unknown groups
     """
 
     if not file and not cmdline:
         raise ValueError('Invalid parameters: you must set either file or cmdline to True')
 
-    normalized: Values = {}
+    normalized: dict[str, dict[str, Any]] = {}
-    options, definitions = config
+    options = config.values
+    definitions = _get_internal_definitions(config=config, persistent=persistent)
     for group_name, group in definitions.items():
         group_options = {}
         if group.persistent and persistent:
-            group_options = get_options(config, group_name)
+            group_options = get_options(Config(options, definitions), group_name)
         for setting_name, setting in group.v.items():
             if (setting.cmdline and cmdline) or (setting.file and file):
                 # Ensures the option exists with the default if not already set
                 value, is_default = get_option(options, setting)
                 if not is_default or default:
                     # User has set a custom value or has requested the default value
-                    group_options[setting_name] = value
+                    group_options[setting.dest] = value
-                elif setting_name in group_options:
+                elif setting.dest in group_options:
                     # default values have been requested to be removed
-                    del group_options[setting_name]
+                    del group_options[setting.dest]
-            elif setting_name in group_options:
+            elif setting.dest in group_options:
                 # Setting type (file or cmdline) has not been requested and should be removed for persistent groups
-                del group_options[setting_name]
+                del group_options[setting.dest]
         normalized[group_name] = group_options
-    return Config(normalized, definitions)
+
+    return Config(normalized, config.definitions)
 
 
 def parse_file(definitions: Definitions, filename: pathlib.Path) -> tuple[Config[Values], bool]:
@@ -445,10 +665,10 @@ def clean_config(
         file: Include file options
         cmdline: Include cmdline options
         default: Include default values in the returned Config object
-        persistent: Include unknown keys in persistent groups
+        persistent: Include unknown keys in persistent groups and unknown groups
     """
 
-    cleaned, _ = normalize_config(config, file=file, cmdline=cmdline, default=default, persistent=persistent)
+    cleaned, _ = cast(Config[_values], normalize_config(config, file=file, cmdline=cmdline, default=default, persistent=persistent))
     for group in list(cleaned.keys()):
         if not cleaned[group]:
             del cleaned[group]
@@ -471,24 +691,22 @@ def get_namespace(
         file: Include file options
         cmdline: Include cmdline options
         default: Include default values in the returned Config object
-        persistent: Include unknown keys in persistent groups
+        persistent: Include unknown keys in persistent groups and unknown groups
     """
-
     if not file and not cmdline:
         raise ValueError('Invalid parameters: you must set either file or cmdline to True')
 
     options: Values
-    definitions: Definitions
+    definitions = _get_internal_definitions(config=config, persistent=persistent)
     if isinstance(config.values, dict):
         options = config.values
-        definitions = config.definitions
     else:
         cfg = normalize_config(config, file=file, cmdline=cmdline, default=default, persistent=persistent)
-        options, definitions = cfg
+        options = cfg.values
     namespace = Namespace()
     for group_name, group in definitions.items():
 
-        group_options = get_options(config, group_name)
+        group_options = get_options(Config(options, definitions), group_name)
         if group.persistent and persistent:
             for name, value in group_options.items():
                 if name in group.v:
@@ -497,7 +715,7 @@ def get_namespace(
                     internal_name = group.v[name].internal_name
                 else:
                     setting_file = setting_cmdline = True
-                    internal_name, is_default = f'{group_name}_' + sanitize_name(name), None
+                    internal_name, is_default = f'{group_name}__' + sanitize_name(name), None
 
                 if ((setting_cmdline and cmdline) or (setting_file and file)) and (not is_default or default):
                     setattr(namespace, internal_name, value)
@@ -509,7 +727,7 @@ def get_namespace(
                 if not is_default or default:
                     # User has set a custom value or has requested the default value
                     setattr(namespace, setting.internal_name, value)
-    return Config(namespace, definitions)
+    return Config(namespace, config.definitions)
 
 
 def save_file(
@@ -544,12 +762,17 @@ def create_argparser(definitions: Definitions, description: str, epilog: str) ->
     argparser = argparse.ArgumentParser(
         description=description, epilog=epilog, formatter_class=argparse.RawTextHelpFormatter,
     )
-    for group in definitions.values():
+
-        for setting in group.v.values():
+    def get_current_group(setting: Setting) -> ArgParser:
-            if setting.cmdline:
+
-                argparse_args, argparse_kwargs = setting.to_argparse()
+        if not setting.group:
-                current_group: ArgParser = argparser
+            return argparser
-                if setting.group:
+
+        # Hard coded exception for positional arguments
+        # Ensures that the option shows at the top of the help output
+        if 'runtime' in setting.group.casefold() and setting.nargs == '*' and not setting.flag:
+            return argparser
+
         if setting.group not in groups:
             if setting.exclusive:
                 groups[setting.group] = argparser.add_argument_group(
@@ -557,10 +780,17 @@ def create_argparser(definitions: Definitions, description: str, epilog: str) ->
                 ).add_mutually_exclusive_group()
             else:
                 groups[setting.group] = argparser.add_argument_group(setting.group)
+        return groups[setting.group]
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', message="'metavar", category=DeprecationWarning, module='argparse')
+
+        for group in definitions.values():
+            for setting in group.v.values():
+                if not setting.cmdline:
+                    continue
+                argparse_args, argparse_kwargs = setting.to_argparse()
+                current_group: ArgParser = get_current_group(setting)
 
-                    # hard coded exception for files
-                    if not (setting.group == 'runtime' and setting.nargs == '*'):
-                        current_group = groups[setting.group]
                 current_group.add_argument(*argparse_args, **argparse_kwargs)
     return argparser
 
@@ -635,24 +865,34 @@ class Manager:
         self.description = description
         self.epilog = epilog
 
+        self.definitions: Definitions
         if isinstance(definitions, Config):
-            self.definitions = definitions.definitions
+            self.definitions = defaultdict(lambda: Group(False, {}), dict(definitions.definitions) or {})
         else:
-            self.definitions = defaultdict(lambda: Group(False, {}), definitions or {})
+            self.definitions = defaultdict(lambda: Group(False, {}), dict(definitions or {}))
 
         self.exclusive_group = False
         self.current_group_name = ''
 
-    def generate_ns(self) -> str:
+    def _get_config(self, c: T | Config[T]) -> Config[T]:
+        if not isinstance(c, Config):
+            return Config(c, self.definitions)
+        return c
+
+    def generate_ns(self) -> tuple[str, str]:
         return generate_ns(self.definitions)
 
+    def generate_dict(self) -> tuple[str, str]:
+        return generate_dict(self.definitions)
+
     def create_argparser(self) -> None:
         self.argparser = create_argparser(self.definitions, self.description, self.epilog)
 
     def add_setting(self, *args: Any, **kwargs: Any) -> None:
         """Passes all arguments through to `Setting`, `group` and `exclusive` are already set"""
+
         setting = Setting(*args, **kwargs, group=self.current_group_name, exclusive=self.exclusive_group)
-        self.definitions[self.current_group_name].v[setting.dest] = setting
+        self.definitions[self.current_group_name].v[setting.setting_name] = setting
 
     def add_group(self, name: str, group: Callable[[Manager], None], exclusive_group: bool = False) -> None:
         """
@@ -663,6 +903,7 @@ class Manager:
             group: A function that registers individual options using :meth:`add_setting`
             exclusive_group: If this group is an argparse exclusive group
         """
+
         if self.current_group_name != '':
             raise ValueError('Sub groups are not allowed')
         self.current_group_name = name
@@ -681,6 +922,7 @@ class Manager:
             group: A function that registers individual options using :meth:`add_setting`
             exclusive_group: If this group is an argparse exclusive group
         """
+
         if self.current_group_name != '':
             raise ValueError('Sub groups are not allowed')
         self.current_group_name = name
@@ -713,9 +955,7 @@ class Manager:
             cmdline: Include cmdline options
         """
 
-        if not isinstance(config, Config):
+        return clean_config(self._get_config(config), file=file, cmdline=cmdline)
-            config = Config(config, self.definitions)
-        return clean_config(config, file=file, cmdline=cmdline)
 
     def normalize_config(
         self,
@@ -735,13 +975,11 @@ class Manager:
             file: Include file options
             cmdline: Include cmdline options
             default: Include default values in the returned Config object
-            persistent: Include unknown keys in persistent groups
+            persistent: Include unknown keys in persistent groups and unknown groups
         """
 
-        if not isinstance(config, Config):
-            config = Config(config, self.definitions)
         return normalize_config(
-            config=config,
+            config=self._get_config(config),
             file=file,
             cmdline=cmdline,
             default=default,
@@ -750,7 +988,7 @@ class Manager:
 
     def get_namespace(
         self,
-        config: Values | Config[Values],
+        config: T | Config[T],
         file: bool = False,
         cmdline: bool = False,
         default: bool = True,
@@ -766,14 +1004,12 @@ class Manager:
             file: Include file options
             cmdline: Include cmdline options
             default: Include default values in the returned Config object
-            persistent: Include unknown keys in persistent groups
+            persistent: Include unknown keys in persistent groups and unknown groups
         """
 
-        if isinstance(config, Config):
+        return get_namespace(
-            self.definitions = config[1]
+            self._get_config(config), file=file, cmdline=cmdline, default=default, persistent=persistent,
-        else:
+        )
-            config = Config(config, self.definitions)
-        return get_namespace(config, file=file, cmdline=cmdline, default=default, persistent=persistent)
 
     def parse_file(self, filename: pathlib.Path) -> tuple[Config[Values], bool]:
         """
@@ -784,6 +1020,7 @@ class Manager:
         Args:
             filename: A pathlib.Path object to read a JSON dictionary from
         """
+
         return parse_file(filename=filename, definitions=self.definitions)
 
     def save_file(self, config: T | Config[T], filename: pathlib.Path) -> bool:
@@ -796,9 +1033,8 @@ class Manager:
             config: The options to save to a json dictionary
             filename: A pathlib.Path object to save the json dictionary to
         """
-        if not isinstance(config, Config):
+
-            config = Config(config, self.definitions)
+        return save_file(self._get_config(config), filename=filename)
-        return save_file(config, filename=filename)
 
     def parse_cmdline(self, args: list[str] | None = None, config: ns[T] = None) -> Config[Values]:
         """
@@ -826,11 +1062,12 @@ class Manager:
 
 __all__ = [
     'Setting',
+    'TypedNS',
     'Group',
     'Values',
     'Definitions',
     'Config',
-    'generate_settings',
+    'generate_ns',
     'sanitize_name',
     'get_option',
     'get_options',
@@ -861,6 +1098,7 @@ def example_group(manager: Manager) -> None:
     manager.add_setting(
         '--verbose', '-v',
         default=False,
+        metavar='nothing',
         action=BooleanOptionalAction,  # Added in Python 3.9
     )
 
@@ -873,27 +1111,53 @@ def persistent_group(manager: Manager) -> None:
     )
 
 
+class SettngsNS(TypedNS):
+    Example_Group__hello: str
+    Example_Group__save: bool
+    Example_Group__verbose: bool
+
+    persistent__test: bool
+
+
+class Example_Group(typing.TypedDict):
+    hello: str
+    save: bool
+    verbose: bool
+
+
+class persistent(typing.TypedDict):
+    test: bool
+
+
+SettngsDict = typing.TypedDict(
+    'SettngsDict', {
+        'Example Group': Example_Group,
+        'persistent': persistent,
+    },
+)
+
+
 def _main(args: list[str] | None = None) -> None:
     settings_path = pathlib.Path('./settings.json')
     manager = Manager(description='This is an example', epilog='goodbye!')
 
-    manager.add_group('example', example_group)
+    manager.add_group('Example Group', example_group)
     manager.add_persistent_group('persistent', persistent_group)
 
-    file_config, success = manager.parse_file(settings_path)
+    file_config, success = cast(Tuple[Config[SettngsDict], bool], manager.parse_file(settings_path))
     file_namespace = manager.get_namespace(file_config, file=True, cmdline=True)
 
-    merged_config = manager.parse_cmdline(args=args, config=file_namespace)
+    merged_config = cast(Config[SettngsDict], manager.parse_cmdline(args=args, config=file_namespace))
-    merged_namespace = manager.get_namespace(merged_config, file=True, cmdline=True)
+    merged_namespace = cast(Config[SettngsNS], manager.get_namespace(merged_config, file=True, cmdline=True))
 
-    print(f'Hello {merged_config.values["example"]["hello"]}')  # noqa: T201
+    print(f'Hello {merged_config.values["Example Group"]["hello"]}')  # noqa: T201
-    if merged_namespace.values.example_save:
+    if merged_namespace.values.Example_Group__save:
         if manager.save_file(merged_config, settings_path):
             print(f'Successfully saved settings to {settings_path}')  # noqa: T201
-        else:
+        else:  # pragma: no cover
             print(f'Failed saving settings to a {settings_path}')  # noqa: T201
-    if merged_namespace.values.example_verbose:
+    if merged_namespace.values.Example_Group__verbose:
-        print(f'{merged_namespace.values.example_verbose=}')  # noqa: T201
+        print(f'{merged_namespace.values.Example_Group__verbose=}')  # noqa: T201
 
 
 if __name__ == '__main__':

setup.cfg

@@ -31,7 +31,7 @@ exclude =
 settngs = py.typed
 
 [tox:tox]
-envlist = py3.8,py3.9,py3.10,py3.11,pypy3
+envlist = py3.8,py3.9,py3.10,py3.11,py3.12,pypy3
 
 [testenv]
 deps = -rrequirements-dev.txt
@@ -90,6 +90,7 @@ fail_under = 95
 [mypy]
 check_untyped_defs = true
 disallow_any_generics = true
+warn_return_any = true
 disallow_incomplete_defs = true
 disallow_untyped_defs = true
 no_implicit_optional = true
@@ -97,7 +98,9 @@ warn_redundant_casts = true
 warn_unused_ignores = true
 
 [mypy-testing.*]
+warn_return_any = false
 disallow_untyped_defs = false
 
 [mypy-tests.*]
+warn_return_any = false
 disallow_untyped_defs = false

testing/settngs.py

@@ -15,52 +15,52 @@ example: list[tuple[list[str], str, str]] = [
     (
         ['--hello', 'lordwelch', '-s'],
         'Hello lordwelch\nSuccessfully saved settings to settings.json\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
     ),
     (
         [],
         'Hello lordwelch\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
     ),
     (
         ['-v'],
-        'Hello lordwelch\nmerged_namespace.values.example_verbose=True\n',
+        'Hello lordwelch\nmerged_namespace.values.Example_Group__verbose=True\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
     ),
     (
         ['-v', '-s'],
-        'Hello lordwelch\nSuccessfully saved settings to settings.json\nmerged_namespace.values.example_verbose=True\n',
+        'Hello lordwelch\nSuccessfully saved settings to settings.json\nmerged_namespace.values.Example_Group__verbose=True\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
     ),
     (
         [],
-        'Hello lordwelch\nmerged_namespace.values.example_verbose=True\n',
+        'Hello lordwelch\nmerged_namespace.values.Example_Group__verbose=True\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false\n  }\n}\n',
     ),
     (
         ['manual settings.json'],
-        'Hello lordwelch\nmerged_namespace.values.example_verbose=True\n',
+        'Hello lordwelch\nmerged_namespace.values.Example_Group__verbose=True\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
     ),
     (
         ['--no-verbose', '-t'],
         'Hello lordwelch\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
     ),
     (
         ['--no-verbose', '-s', '-t'],
         'Hello lordwelch\nSuccessfully saved settings to settings.json\n',
-        '{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": true,\n    "hello": "world"\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": false\n  },\n  "persistent": {\n    "test": true,\n    "hello": "world"\n  }\n}\n',
     ),
     (
         ['--hello', 'world', '--no-verbose', '--no-test', '-s'],
         'Hello world\nSuccessfully saved settings to settings.json\n',
-        '{\n  "example": {\n    "hello": "world",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "world",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
     ),
     (
         [],
         'Hello world\n',
-        '{\n  "example": {\n    "hello": "world",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
+        '{\n  "Example Group": {\n    "hello": "world",\n    "verbose": false\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n',
     ),
 ]
 success = [
@@ -77,13 +77,15 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test_setting',  # dest is calculated by Setting and is not used by argparse
             'dest': 'test_setting',  # dest is calculated by Setting and is not used by argparse
             'display_name': 'test_setting',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': True,
             'group': 'tst',
             'help': None,
-            'internal_name': 'tst_test_setting',  # Should almost always be "{group}_{dest}"
+            'internal_name': 'tst__test_setting',  # Should almost always be "{group}__{dest}"
             'metavar': 'TEST_SETTING',  # Set manually so argparse doesn't use TST_TEST
             'nargs': None,
             'required': None,
@@ -94,7 +96,7 @@ success = [
                 'choices': None,
                 'const': None,
                 'default': None,
-                'dest': 'tst_test_setting',
+                'dest': 'tst__test_setting',
                 'help': None,
                 'metavar': 'TEST_SETTING',
                 'nargs': None,
@@ -117,13 +119,15 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test',  # setting_name is calculated by Setting and is not used by argparse
             'dest': 'testing',  # dest is calculated by Setting and is not used by argparse
             'display_name': 'testing',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': True,
             'group': 'tst',
             'help': None,
-            'internal_name': 'tst_testing',  # Should almost always be "{group}_{dest}"
+            'internal_name': 'tst__testing',  # Should almost always be "{group}__{dest}"
             'metavar': 'TESTING',  # Set manually so argparse doesn't use TST_TEST
             'nargs': None,
             'required': None,
@@ -134,7 +138,7 @@ success = [
                 'choices': None,
                 'const': None,
                 'default': None,
-                'dest': 'tst_testing',
+                'dest': 'tst__testing',
                 'help': None,
                 'metavar': 'TESTING',
                 'nargs': None,
@@ -156,13 +160,15 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test',  # dest is calculated by Setting and is not used by argparse
             'dest': 'test',  # dest is calculated by Setting and is not used by argparse
             'display_name': 'test',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': True,
             'group': 'tst',
             'help': None,
-            'internal_name': 'tst_test',  # Should almost always be "{group}_{dest}"
+            'internal_name': 'tst__test',  # Should almost always be "{group}__{dest}"
             'metavar': 'TEST',  # Set manually so argparse doesn't use TST_TEST
             'nargs': None,
             'required': None,
@@ -173,7 +179,7 @@ success = [
                 'choices': None,
                 'const': None,
                 'default': None,
-                'dest': 'tst_test',
+                'dest': 'tst__test',
                 'help': None,
                 'metavar': 'TEST',
                 'nargs': None,
@@ -196,13 +202,15 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test',  # dest is calculated by Setting and is not used by argparse
             'dest': 'test',  # dest is calculated by Setting and is not used by argparse
             'display_name': 'test',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': True,
             'group': 'tst',
             'help': None,
-            'internal_name': 'tst_test',  # Should almost always be "{group}_{dest}"
+            'internal_name': 'tst__test',  # Should almost always be "{group}__{dest}"
             'metavar': None,  # store_true does not get a metavar
             'nargs': None,
             'required': None,
@@ -213,7 +221,7 @@ success = [
                 'choices': None,
                 'const': None,
                 'default': None,
-                'dest': 'tst_test',
+                'dest': 'tst__test',
                 'help': None,
                 'metavar': None,
                 'nargs': None,
@@ -235,13 +243,15 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test',
             'dest': 'test',
             'display_name': 'test',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': True,
             'group': 'tst',
             'help': None,
-            'internal_name': 'tst_test',
+            'internal_name': 'tst__test',
             'metavar': 'TEST',
             'nargs': None,
             'required': None,
@@ -252,7 +262,7 @@ success = [
                 'choices': None,
                 'const': None,
                 'default': None,
-                'dest': 'tst_test',
+                'dest': 'tst__test',
                 'help': None,
                 'metavar': 'TEST',
                 'nargs': None,
@@ -274,18 +284,20 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test',
             'dest': 'test',
             'display_name': 'test',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': False,
             'group': 'tst',
             'help': None,
-            'internal_name': 'tst_test',
+            'internal_name': 'tst__test',
             'metavar': 'TEST',
             'nargs': None,
             'required': None,
             'type': None,
-            'argparse_args': ('tst_test',),
+            'argparse_args': ('tst__test',),
             'argparse_kwargs': {
                 'action': None,
                 'choices': None,
@@ -311,10 +323,12 @@ success = [
             'cmdline': True,
             'const': None,
             'default': None,
+            'setting_name': 'test',
             'dest': 'test',
             'display_name': 'test',  # defaults to dest
             'exclusive': False,
             'file': True,
+            'flag': True,
             'group': '',
             'help': None,
             'internal_name': 'test',  # No group, leading _ is stripped

tests/settngs_test.py

@@ -17,10 +17,43 @@ from testing.settngs import failure
 from testing.settngs import success
 
 
-if sys.version_info < (3, 9):  # pragma: no cover
+if sys.version_info >= (3, 10):  # pragma: no cover
+    List = list
+    Set = set
+    help_output = '''\
+usage: __main__.py [-h] [TEST ...]
+
+positional arguments:
+  TEST
+
+options:
+  -h, --help  show this help message and exit
+'''
+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 ...]]
+
+positional arguments:
+  TEST
+
+optional arguments:
+  -h, --help  show this help message and exit
+'''
+
 else:  # pragma: no cover
     List = list
+    Set = set
+    help_output = '''\
+usage: __main__.py [-h] [TEST ...]
+
+positional arguments:
+  TEST
+
+optional arguments:
+  -h, --help  show this help message and exit
+'''
 
 
 @pytest.fixture
@@ -63,6 +96,55 @@ def test_add_setting(settngs_manager):
     assert settngs_manager.add_setting('--test') is None
 
 
+def test_add_setting_invalid_name(settngs_manager):
+    with pytest.raises(Exception, match='Cannot use test¥ in a namespace'):
+        assert settngs_manager.add_setting('--test¥') is None
+
+
+def test_sub_group(settngs_manager):
+    with pytest.raises(Exception, match='Sub groups are not allowed'):
+        settngs_manager.add_group('tst', lambda parser: parser.add_group('tst', lambda parser: parser.add_setting('--test2', default='hello')))
+
+
+def test_sub_persistent_group(settngs_manager):
+    with pytest.raises(Exception, match='Sub groups are not allowed'):
+        settngs_manager.add_persistent_group('tst', lambda parser: parser.add_persistent_group('tst', lambda parser: parser.add_setting('--test2', default='hello')))
+
+
+def test_redefine_persistent_group(settngs_manager):
+    settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test2', default='hello'))
+    with pytest.raises(Exception, match='Group already exists and is not persistent'):
+        settngs_manager.add_persistent_group('tst', None)
+
+
+def test_exclusive_group(settngs_manager):
+    settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'), exclusive_group=True)
+    settngs_manager.create_argparser()
+    args = settngs_manager.argparser.parse_args(['--test', 'never'])
+    assert args.tst__test == 'never'
+
+    with pytest.raises(SystemExit):
+        settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test2', default='hello'), exclusive_group=True)
+        settngs_manager.create_argparser()
+        args = settngs_manager.argparser.parse_args(['--test', 'never', '--test2', 'never'])
+
+
+def test_files_group(capsys, settngs_manager):
+    settngs_manager.add_group('runtime', lambda parser: parser.add_setting('test', default='hello', nargs='*'))
+    settngs_manager.create_argparser()
+    settngs_manager.argparser.print_help()
+    captured = capsys.readouterr()
+    assert captured.out == help_output
+
+
+def test_setting_without_group(capsys, settngs_manager):
+    settngs_manager.add_setting('test', default='hello', nargs='*')
+    settngs_manager.create_argparser()
+    settngs_manager.argparser.print_help()
+    captured = capsys.readouterr()
+    assert captured.out == help_output
+
+
 class TestValues:
 
     def test_invalid_normalize(self, settngs_manager):
@@ -81,6 +163,11 @@ class TestValues:
         defaults, _ = settngs_manager.defaults()
         assert defaults['tst']['test'] == 'hello'
 
+    def test_get_defaults_group_space(self, settngs_manager):
+        settngs_manager.add_group('Testing tst', lambda parser: parser.add_setting('--test', default='hello'))
+        defaults, _ = settngs_manager.defaults()
+        assert defaults['Testing tst']['test'] == 'hello'
+
     def test_cmdline_only(self, settngs_manager):
         settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello', file=False))
         settngs_manager.add_group('tst2', lambda parser: parser.add_setting('--test2', default='hello', cmdline=False))
@@ -125,6 +212,24 @@ class TestValues:
         assert non_defaults_normalized.values['tst'] == {'test': 'world'}
         assert non_defaults_normalized.values['tst_persistent'] == {'test': 'world'}
 
+    def test_normalize_dest(self, settngs_manager):
+        settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
+        settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test2', dest='test', default='hello'))
+        settngs_manager.add_persistent_group('tst_persistent', lambda parser: parser.add_setting('--test', default='hello'))
+
+        defaults = settngs_manager.defaults()
+        defaults_normalized = settngs_manager.normalize_config(defaults, file=True, default=False)
+        assert defaults_normalized.values['tst'] == {}
+        assert defaults_normalized.values['tst_persistent'] == {}
+
+        non_defaults = settngs_manager.defaults()
+        non_defaults.values['tst']['test'] = 'world'
+        non_defaults.values['tst_persistent']['test'] = 'world'
+        non_defaults_normalized = settngs_manager.normalize_config(non_defaults, file=True, default=False)
+
+        assert non_defaults_normalized.values['tst'] == {'test': 'world'}
+        assert non_defaults_normalized.values['tst_persistent'] == {'test': 'world'}
+
     def test_normalize(self, settngs_manager):
         settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
         settngs_manager.add_persistent_group('persistent', lambda parser: parser.add_setting('--world', default='world'))
@@ -142,6 +247,29 @@ class TestValues:
         assert normalized['persistent']['hello'] == 'success'
         assert normalized['persistent']['world'] == 'world'
 
+    def test_unknown_group(self):
+        manager = settngs.Manager()
+        manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
+        manager.add_persistent_group('persistent', lambda parser: parser.add_setting('--world', default='world'))
+
+        manager_unknown = settngs.Manager()
+        manager_unknown.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
+        # This manager doesn't know about this group
+        # manager_unknown.add_persistent_group('persistent', lambda parser: parser.add_setting('--world', default='world'))
+
+        defaults = manager.defaults()
+        defaults.values['test'] = 'fail'  # type: ignore[index] # Not defined in manager, should be removed
+        defaults.values['persistent']['hello'] = 'success'  # Group is not defined in manager_unknown, should stay
+
+        normalized, _ = manager_unknown.normalize_config(defaults.values, file=True)
+
+        assert 'test' not in normalized
+        assert 'tst' in normalized
+        assert 'test' in normalized['tst']
+        assert normalized['tst']['test'] == 'hello'
+        assert normalized['persistent']['hello'] == 'success'
+        assert normalized['persistent']['world'] == 'world'
+
 
 class TestNamespace:
 
@@ -159,7 +287,12 @@ class TestNamespace:
     def test_get_defaults_group(self, settngs_manager):
         settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
         defaults, _ = settngs_manager.get_namespace(settngs_manager.defaults(), file=True, cmdline=True)
-        assert defaults.tst_test == 'hello'
+        assert defaults.tst__test == 'hello'
+
+    def test_get_defaults_group_space(self, settngs_manager):
+        settngs_manager.add_group('Testing tst', lambda parser: parser.add_setting('--test', default='hello'))
+        defaults, _ = settngs_manager.get_namespace(settngs_manager.defaults(), file=True, cmdline=True)
+        assert defaults.Testing_tst__test == 'hello'
 
     def test_cmdline_only(self, settngs_manager):
         settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello', file=False))
@@ -168,11 +301,11 @@ class TestNamespace:
         file_normalized, _ = settngs_manager.get_namespace(settngs_manager.normalize_config(settngs_manager.defaults(), file=True), file=True)
         cmdline_normalized, _ = settngs_manager.get_namespace(settngs_manager.normalize_config(settngs_manager.defaults(), cmdline=True), cmdline=True)
 
-        assert 'tst_test' not in file_normalized.__dict__
+        assert 'tst__test' not in file_normalized.__dict__
-        assert 'tst2_test2' in file_normalized.__dict__
+        assert 'tst2__test2' in file_normalized.__dict__
 
-        assert 'tst_test' in cmdline_normalized.__dict__
+        assert 'tst__test' in cmdline_normalized.__dict__
-        assert 'tst2_test2' not in cmdline_normalized.__dict__
+        assert 'tst2__test2' not in cmdline_normalized.__dict__
 
     def test_cmdline_only_persistent_group(self, settngs_manager):
         settngs_manager.add_persistent_group('tst', lambda parser: parser.add_setting('--test', default='hello', file=False))
@@ -181,11 +314,11 @@ class TestNamespace:
         file_normalized, _ = settngs_manager.get_namespace(settngs_manager.normalize_config(settngs_manager.defaults(), file=True), file=True)
         cmdline_normalized, _ = settngs_manager.get_namespace(settngs_manager.normalize_config(settngs_manager.defaults(), cmdline=True), cmdline=True)
 
-        assert 'tst_test' not in file_normalized.__dict__
+        assert 'tst__test' not in file_normalized.__dict__
-        assert 'tst2_test2' in file_normalized.__dict__
+        assert 'tst2__test2' in file_normalized.__dict__
 
-        assert 'tst_test' in cmdline_normalized.__dict__
+        assert 'tst__test' in cmdline_normalized.__dict__
-        assert 'tst2_test2' not in cmdline_normalized.__dict__
+        assert 'tst2__test2' not in cmdline_normalized.__dict__
 
     def test_normalize_defaults(self, settngs_manager):
         settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
@@ -197,12 +330,29 @@ class TestNamespace:
         assert defaults_normalized.values.__dict__ == {}
 
         non_defaults = settngs_manager.get_namespace(settngs_manager.defaults(), file=True, cmdline=True)
-        non_defaults.values.tst_test = 'world'
+        non_defaults.values.tst__test = 'world'
-        non_defaults.values.tst_persistent_test = 'world'
+        non_defaults.values.tst_persistent__test = 'world'
         non_defaults_normalized = settngs_manager.get_namespace(settngs_manager.normalize_config(non_defaults, file=True, default=False), file=True, default=False)
 
-        assert non_defaults_normalized.values.tst_test == 'world'
+        assert non_defaults_normalized.values.tst__test == 'world'
-        assert non_defaults_normalized.values.tst_persistent_test == 'world'
+        assert non_defaults_normalized.values.tst_persistent__test == 'world'
+
+    def test_normalize_dest(self, settngs_manager):
+        settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
+        settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test2', dest='test', default='hello'))
+        settngs_manager.add_persistent_group('tst_persistent', lambda parser: parser.add_setting('--test', default='hello'))
+
+        defaults = settngs_manager.defaults()
+        defaults_normalized = settngs_manager.get_namespace(settngs_manager.normalize_config(defaults, file=True, default=False), file=True, default=False)
+        assert defaults_normalized.values.__dict__ == {}
+
+        non_defaults = settngs_manager.get_namespace(settngs_manager.defaults(), file=True, cmdline=True)
+        non_defaults.values.tst__test = 'world'
+        non_defaults.values.tst_persistent__test = 'world'
+        non_defaults_normalized = settngs_manager.get_namespace(settngs_manager.normalize_config(non_defaults, file=True, default=False), file=True, default=False)
+
+        assert non_defaults_normalized.values.tst__test == 'world'
+        assert non_defaults_normalized.values.tst_persistent__test == 'world'
 
     def test_normalize(self, settngs_manager):
         settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
@@ -210,15 +360,37 @@ class TestNamespace:
 
         defaults = settngs_manager.get_namespace(settngs_manager.defaults(), file=True, cmdline=True)
         defaults.values.test = 'fail'  # Not defined in settngs_manager, should be removed
-        defaults.values.persistent_hello = 'success'  # Not defined in settngs_manager, should stay
+        defaults.values.persistent__hello = 'success'  # Not defined in settngs_manager, should stay
 
         normalized, _ = settngs_manager.get_namespace(settngs_manager.normalize_config(defaults, file=True), file=True)
 
         assert not hasattr(normalized, 'test')
-        assert hasattr(normalized, 'tst_test')
+        assert hasattr(normalized, 'tst__test')
-        assert normalized.tst_test == 'hello'
+        assert normalized.tst__test == 'hello'
-        assert normalized.persistent_hello == 'success'
+        assert normalized.persistent__hello == 'success'
-        assert normalized.persistent_world == 'world'
+        assert normalized.persistent__world == 'world'
+
+    def test_normalize_unknown_group(self, settngs_manager):
+        manager = settngs.Manager()
+        manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
+        manager.add_persistent_group('persistent', lambda parser: parser.add_setting('--world', default='world'))
+
+        manager_unknown = settngs.Manager()
+        manager_unknown.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
+        # This manager doesn't know about this group
+        # manager_unknown.add_persistent_group('persistent', lambda parser: parser.add_setting('--world', default='world'))
+
+        defaults = manager.get_namespace(manager.defaults(), file=True, cmdline=True)
+        defaults.values.test = 'fail'  # Not defined in manager, should be removed
+        defaults.values.persistent__hello = 'success'  # Not defined in manager, should stay
+
+        normalized, _ = manager_unknown.get_namespace(defaults.values, file=True)
+
+        assert not hasattr(normalized, 'test')
+        assert hasattr(normalized, 'tst__test')
+        assert normalized.tst__test == 'hello'
+        assert normalized.persistent__hello == 'success'
+        assert normalized.persistent__world == 'world'
 
 
 def test_get_namespace_with_namespace(settngs_manager):
@@ -230,7 +402,7 @@ def test_get_namespace_with_namespace(settngs_manager):
 def test_get_namespace_group(settngs_manager):
     settngs_manager.add_group('tst', lambda parser: parser.add_setting('--test', default='hello'))
     defaults, _ = settngs_manager.get_namespace(settngs_manager.defaults(), file=True)
-    assert defaults.tst_test == 'hello'
+    assert defaults.tst__test == 'hello'
 
 
 def test_clean_config(settngs_manager):
@@ -261,8 +433,8 @@ def test_parse_cmdline(settngs_manager):
 
 namespaces = (
     lambda definitions: settngs.Config({'tst': {'test': 'fail', 'test2': 'success'}}, definitions),
-    lambda definitions: settngs.Config(argparse.Namespace(tst_test='fail', tst_test2='success'), definitions),
+    lambda definitions: settngs.Config(argparse.Namespace(tst__test='fail', tst__test2='success'), definitions),
-    lambda definitions: argparse.Namespace(tst_test='fail', tst_test2='success'),
+    lambda definitions: argparse.Namespace(tst__test='fail', tst__test2='success'),
 )
 
 
@@ -449,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):
     ...
 
@@ -475,82 +659,183 @@ 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 = (
-    (settngs.Setting('-t', '--test'), str),
+    (0, settngs.Setting('-t', '--test'), str, True),
-    (settngs.Setting('-t', '--test', cmdline=False), 'Any'),
+    (1, settngs.Setting('-t', '--test', cmdline=False), 'Any', True),
-    (settngs.Setting('-t', '--test', default=1, file=True, cmdline=False), int),
+    (2, settngs.Setting('-t', '--test', default=1, file=True, cmdline=False), int, False),
-    (settngs.Setting('-t', '--test', action='count'), int),
+    (3, settngs.Setting('-t', '--test', default='test'), str, False),
-    (settngs.Setting('-t', '--test', action='append'), List[str]),
+    (4, settngs.Setting('-t', '--test', default='test', file=True, cmdline=False), str, False),
-    (settngs.Setting('-t', '--test', action='extend'), List[str]),
+    (5, settngs.Setting('-t', '--test', action='count'), int, True),
-    (settngs.Setting('-t', '--test', action='store_const', const=1), int),
+    (6, settngs.Setting('-t', '--test', action='append'), List[str], True),
-    (settngs.Setting('-t', '--test', action='append_const', const=1), list),
+    (7, settngs.Setting('-t', '--test', action='extend'), List[str], True),
-    (settngs.Setting('-t', '--test', action='store_true'), bool),
+    (8, settngs.Setting('-t', '--test', nargs='+'), List[str], True),
-    (settngs.Setting('-t', '--test', action='store_false'), bool),
+    (9, settngs.Setting('-t', '--test', action='store_const', const=1), int, True),
-    (settngs.Setting('-t', '--test', action=settngs.BooleanOptionalAction), bool),
+    (10, settngs.Setting('-t', '--test', action='append_const', const=1), List[int], True),
-    (settngs.Setting('-t', '--test', action=_customAction), 'Any'),
+    (11, settngs.Setting('-t', '--test', action='store_true'), bool, False),
-    (settngs.Setting('-t', '--test', action='help'), None),
+    (12, settngs.Setting('-t', '--test', action='store_false'), bool, False),
-    (settngs.Setting('-t', '--test', action='version'), None),
+    (13, settngs.Setting('-t', '--test', action=settngs.BooleanOptionalAction), bool, True),
-    (settngs.Setting('-t', '--test', type=int), int),
+    (14, settngs.Setting('-t', '--test', action=_customAction), 'Any', True),
-    (settngs.Setting('-t', '--test', type=_typed_function), test_type),
+    (15, settngs.Setting('-t', '--test', action='help'), None, True),
-    (settngs.Setting('-t', '--test', type=_untyped_function, default=1), int),
+    (16, settngs.Setting('-t', '--test', action='version'), None, True),
-    (settngs.Setting('-t', '--test', type=_untyped_function), 'Any'),
+    (17, settngs.Setting('-t', '--test', type=int), int, True),
+    (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('setting,typ', types)
+@pytest.mark.parametrize('num,setting,typ,noneable_expected', types)
-def test_guess_type(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
+
+import settngs
+{extra_imports}
+
+class SettngsNS(settngs.TypedNS):
+    test__test: {typ}
+'''
+no_type_expected_src = '''from __future__ import annotations
+
+import settngs
+
+
+class SettngsNS(settngs.TypedNS):
+    ...
+'''
 settings = (
-    (lambda parser: parser.add_setting('-t', '--test'), 'str'),
+    (0, lambda parser: parser.add_setting('-t', '--test'), expected_src.format(extra_imports='', typ='str | None')),
-    (lambda parser: parser.add_setting('-t', '--test', cmdline=False), 'typing.Any'),
+    (1, lambda parser: parser.add_setting('-t', '--test', cmdline=False), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
-    (lambda parser: parser.add_setting('-t', '--test', default=1, file=True, cmdline=False), 'int'),
+    (2, lambda parser: parser.add_setting('-t', '--test', default=1, file=True, cmdline=False), expected_src.format(extra_imports='', typ='int')),
-    (lambda parser: parser.add_setting('-t', '--test', action='count'), 'int'),
+    (3, lambda parser: parser.add_setting('-t', '--test', default='test'), expected_src.format(extra_imports='', typ='str')),
-    (lambda parser: parser.add_setting('-t', '--test', action='append'), List[str]),
+    (4, lambda parser: parser.add_setting('-t', '--test', default='test', file=True, cmdline=False), expected_src.format(extra_imports='', typ='str')),
-    (lambda parser: parser.add_setting('-t', '--test', action='extend'), List[str]),
+    (5, lambda parser: parser.add_setting('-t', '--test', action='count'), expected_src.format(extra_imports='', typ='int | None')),
-    (lambda parser: parser.add_setting('-t', '--test', action='store_const', const=1), 'int'),
+    (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')),
-    (lambda parser: parser.add_setting('-t', '--test', action='append_const', const=1), 'list'),
+    (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')),
-    (lambda parser: parser.add_setting('-t', '--test', action='store_true'), 'bool'),
+    (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')),
-    (lambda parser: parser.add_setting('-t', '--test', action='store_false'), 'bool'),
+    (9, lambda parser: parser.add_setting('-t', '--test', action='store_const', const=1), expected_src.format(extra_imports='', typ='int | None')),
-    (lambda parser: parser.add_setting('-t', '--test', action=settngs.BooleanOptionalAction), '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')),
-    (lambda parser: parser.add_setting('-t', '--test', action=_customAction), 'typing.Any'),
+    (11, lambda parser: parser.add_setting('-t', '--test', action='store_true'), expected_src.format(extra_imports='', typ='bool')),
-    (lambda parser: parser.add_setting('-t', '--test', action='help'), None),
+    (12, lambda parser: parser.add_setting('-t', '--test', action='store_false'), expected_src.format(extra_imports='', typ='bool')),
-    (lambda parser: parser.add_setting('-t', '--test', action='version'), None),
+    (13, lambda parser: parser.add_setting('-t', '--test', action=settngs.BooleanOptionalAction), expected_src.format(extra_imports='', typ='bool | None')),
-    (lambda parser: parser.add_setting('-t', '--test', type=int), 'int'),
+    (14, lambda parser: parser.add_setting('-t', '--test', action=_customAction), expected_src.format(extra_imports='import typing\n', typ='typing.Any')),
-    (lambda parser: parser.add_setting('-t', '--test', type=_typed_function), 'tests.settngs_test.test_type'),
+    (15, lambda parser: parser.add_setting('-t', '--test', action='help'), no_type_expected_src),
-    (lambda parser: parser.add_setting('-t', '--test', type=_untyped_function, default=1), 'int'),
+    (16, lambda parser: parser.add_setting('-t', '--test', action='version'), no_type_expected_src),
-    (lambda parser: parser.add_setting('-t', '--test', type=_untyped_function), 'typing.Any'),
+    (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=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')),
 )
 
 
-@pytest.mark.parametrize('set_options,typ', settings)
+@pytest.mark.parametrize('num,set_options,expected', settings)
-def test_generate_ns(settngs_manager, set_options, typ):
+def test_generate_ns(settngs_manager, num, set_options, expected):
     settngs_manager.add_group('test', set_options)
 
-    src = '''\
+    imports, types = settngs_manager.generate_ns()
-from __future__ import annotations
+    generated_src = '\n\n\n'.join((imports, types))
+
+    assert generated_src == expected
+
+    ast.parse(generated_src)
+
+
+expected_src_dict = '''from __future__ import annotations
+
 import typing
-import settngs
+{extra_imports}
-'''
-    if typ == 'tests.settngs_test.test_type':
-        src += 'import tests.settngs_test\n'
-    src += '''
-class settngs_namespace(settngs.TypedNS):
-'''
-    if typ is None:
-        src += '    ...\n'
-    else:
-        src += f'    {settngs_manager.definitions["test"].v["test"].internal_name}: {typ}\n'
 
-    generated_src = settngs_manager.generate_ns()
+class test(typing.TypedDict):
+    test: {typ}
 
-    assert generated_src == src
+
+class SettngsDict(typing.TypedDict):
+    test: test
+'''
+no_type_expected_src_dict = '''from __future__ import annotations
+
+import typing
+
+
+class test(typing.TypedDict):
+    ...
+
+
+class SettngsDict(typing.TypedDict):
+    test: test
+'''
+settings_dict = (
+    (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', default='test'), expected_src_dict.format(extra_imports='', typ='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='count'), expected_src_dict.format(extra_imports='', typ='int | None')),
+    (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='extend'), expected_src_dict.format(extra_imports='', typ=f'{List[str]} | None')),
+    (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_const', const=1), expected_src_dict.format(extra_imports='', typ='int | None')),
+    (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='store_true'), expected_src_dict.format(extra_imports='', typ='bool')),
+    (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=settngs.BooleanOptionalAction), expected_src_dict.format(extra_imports='', typ='bool | None')),
+    (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', action='help'), no_type_expected_src_dict),
+    (16, lambda parser: parser.add_setting('-t', '--test', action='version'), no_type_expected_src_dict),
+    (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=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')),
+)
+
+
+@pytest.mark.parametrize('num,set_options,expected', settings_dict)
+def test_generate_dict(settngs_manager, num, set_options, expected):
+    settngs_manager.add_group('test', set_options)
+
+    imports, types = settngs_manager.generate_dict()
+    generated_src = '\n\n\n'.join((imports, types))
+
+    assert generated_src == expected
 
     ast.parse(generated_src)
 
@@ -564,7 +849,7 @@ def test_example(capsys, tmp_path, monkeypatch):
     for args, expected_out, expected_file in example:
         if args == ['manual settings.json']:
             settings_file.unlink()
-            settings_file.write_text('{\n  "example": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n')
+            settings_file.write_text('{\n  "Example Group": {\n    "hello": "lordwelch",\n    "verbose": true\n  },\n  "persistent": {\n    "test": false,\n    "hello": "world"\n  }\n}\n')
             i += 1
             continue
         else: