Add default settings source.

Author: kschwab

pydantic_settings/main.py

@@ -11,6 +11,7 @@
 from .sources import (
     ENV_FILE_SENTINEL,
     CliSettingsSource,
+    DefaultSettingsSource,
     DotEnvSettingsSource,
     DotenvType,
     EnvSettingsSource,
@@ -264,6 +265,7 @@ def _settings_build_values(
         secrets_dir = _secrets_dir if _secrets_dir is not None else self.model_config.get('secrets_dir')
 
         # Configure built-in sources
+        default_settings = DefaultSettingsSource(self.__class__)
         init_settings = InitSettingsSource(self.__class__, init_kwargs=init_kwargs)
         env_settings = EnvSettingsSource(
             self.__class__,
@@ -296,7 +298,7 @@ def _settings_build_values(
             env_settings=env_settings,
             dotenv_settings=dotenv_settings,
             file_secret_settings=file_secret_settings,
-        )
+        ) + (default_settings,)
         if not any([source for source in sources if isinstance(source, CliSettingsSource)]):
             if cli_parse_args is not None or cli_settings_source is not None:
                 cli_settings = (

pydantic_settings/sources.py

@@ -10,7 +10,7 @@
 from abc import ABC, abstractmethod
 from argparse import SUPPRESS, ArgumentParser, HelpFormatter, Namespace, _SubParsersAction
 from collections import deque
-from dataclasses import is_dataclass
+from dataclasses import asdict, is_dataclass
 from enum import Enum
 from pathlib import Path
 from types import FunctionType
@@ -246,6 +246,74 @@ def __call__(self) -> dict[str, Any]:
         pass
 
 
+class DefaultSettingsSource(PydanticBaseSettingsSource):
+    """
+    Source class for loading default values.
+    """
+
+    def __init__(self, settings_cls: type[BaseSettings]):
+        super().__init__(settings_cls)
+        self.defaults = self._get_defaults(settings_cls)
+
+    def _get_defaults(self, settings_cls: type[BaseSettings]) -> dict[str, Any]:
+        defaults: dict[str, Any] = {}
+        if self.config.get('validate_default'):
+            fields = (
+                settings_cls.__pydantic_fields__ if is_pydantic_dataclass(settings_cls) else settings_cls.model_fields
+            )
+            for field_name, field_info in fields.items():
+                if field_info.validate_default is not False:
+                    resolved_name = self._get_resolved_name(field_name, field_info)
+                    if field_info.default not in (PydanticUndefined, None):
+                        if is_model_class(field_info.annotation):
+                            defaults[resolved_name] = field_info.default.model_dump()
+                        elif is_dataclass(field_info.annotation):
+                            defaults[resolved_name] = asdict(field_info.default)
+                        else:
+                            defaults[resolved_name] = field_info.default
+                    elif field_info.default_factory is not None:
+                        defaults[resolved_name] = field_info.default_factory
+        return defaults
+
+    def _get_resolved_name(self, field_name: str, field_info: FieldInfo) -> str:
+        if not any((field_info.alias, field_info.validation_alias)):
+            return field_name
+
+        resolved_names: list[str] = []
+        is_alias_path_only: bool = True
+        new_alias_paths: list[AliasPath] = []
+        for alias in (field_info.alias, field_info.validation_alias):
+            if alias is None:
+                continue
+            elif isinstance(alias, str):
+                resolved_names.append(alias)
+                is_alias_path_only = False
+            elif isinstance(alias, AliasChoices):
+                for name in alias.choices:
+                    if isinstance(name, str):
+                        resolved_names.append(name)
+                        is_alias_path_only = False
+                    else:
+                        new_alias_paths.append(name)
+            else:
+                new_alias_paths.append(alias)
+        for alias_path in new_alias_paths:
+            name = cast(str, alias_path.path[0])
+            if not resolved_names and is_alias_path_only:
+                resolved_names.append(name)
+        return tuple(dict.fromkeys(resolved_names))[0]
+
+    def get_field_value(self, field: FieldInfo, field_name: str) -> tuple[Any, str, bool]:
+        # Nothing to do here. Only implement the return statement to make mypy happy
+        return None, '', False
+
+    def __call__(self) -> dict[str, Any]:
+        return self.defaults
+
+    def __repr__(self) -> str:
+        return f'DefaultSettingsSource(init_kwargs={self.defaults!r})'
+
+
 class InitSettingsSource(PydanticBaseSettingsSource):
     """
     Source class for loading values provided during settings class initialization.

tests/test_settings.py

@@ -491,6 +491,26 @@ class ComplexSettings(BaseSettings):
     ]
 
 
+def test_env_default_settings(env):
+    class NestedA(BaseModel):
+        v0: bool
+        v1: bool
+
+    class NestedB(BaseModel):
+        v0: bool = False
+        v1: bool = True
+
+    class SettingsDefaultsA(BaseSettings, env_nested_delimiter='__'):
+        nested: NestedB = NestedB()
+
+    class SettingsDefaultsB(BaseSettings, env_nested_delimiter='__'):
+        nested: NestedA = NestedA(v0=False, v1=True)
+
+    env.set('NESTED__V0', 'True')
+    assert SettingsDefaultsA().model_dump() == {'nested': {'v0': True, 'v1': True}}
+    assert SettingsDefaultsB().model_dump() == {'nested': {'v0': True, 'v1': True}}
+
+
 def test_env_str(env):
     class Settings(BaseSettings):
         apple: str = Field(None, validation_alias='BOOM')