Add default_objects_copy_by_value flag.

Author: kschwab

pydantic_settings/main.py

@@ -24,6 +24,7 @@
 
 class SettingsConfigDict(ConfigDict, total=False):
     case_sensitive: bool
+    default_objects_copy_by_value: bool | None
     env_prefix: str
     env_file: DotenvType | None
     env_file_encoding: str | None
@@ -89,6 +90,8 @@ class BaseSettings(BaseModel):
 
     Args:
         _case_sensitive: Whether environment variables names should be read with case-sensitivity. Defaults to `None`.
+        _default_objects_copy_by_value: Whether default `BaseModel` objects should use copy-by-value instead of
+            copy-by-reference when compiling sources. Defaults to `False`.
         _env_prefix: Prefix for all environment variables. Defaults to `None`.
         _env_file: The env file(s) to load settings values from. Defaults to `Path('')`, which
             means that the value from `model_config['env_file']` should be used. You can also pass
@@ -121,6 +124,7 @@ class BaseSettings(BaseModel):
     def __init__(
         __pydantic_self__,
         _case_sensitive: bool | None = None,
+        _default_objects_copy_by_value: bool | None = None,
         _env_prefix: str | None = None,
         _env_file: DotenvType | None = ENV_FILE_SENTINEL,
         _env_file_encoding: str | None = None,
@@ -146,6 +150,7 @@ def __init__(
             **__pydantic_self__._settings_build_values(
                 values,
                 _case_sensitive=_case_sensitive,
+                _default_objects_copy_by_value=_default_objects_copy_by_value,
                 _env_prefix=_env_prefix,
                 _env_file=_env_file,
                 _env_file_encoding=_env_file_encoding,
@@ -195,6 +200,7 @@ def _settings_build_values(
         self,
         init_kwargs: dict[str, Any],
         _case_sensitive: bool | None = None,
+        _default_objects_copy_by_value: bool | None = None,
         _env_prefix: str | None = None,
         _env_file: DotenvType | None = None,
         _env_file_encoding: str | None = None,
@@ -217,6 +223,11 @@ def _settings_build_values(
         # Determine settings config values
         case_sensitive = _case_sensitive if _case_sensitive is not None else self.model_config.get('case_sensitive')
         env_prefix = _env_prefix if _env_prefix is not None else self.model_config.get('env_prefix')
+        default_objects_copy_by_value = (
+            _default_objects_copy_by_value
+            if _default_objects_copy_by_value is not None
+            else self.model_config.get('default_objects_copy_by_value')
+        )
         env_file = _env_file if _env_file != ENV_FILE_SENTINEL else self.model_config.get('env_file')
         env_file_encoding = (
             _env_file_encoding if _env_file_encoding is not None else self.model_config.get('env_file_encoding')
@@ -265,8 +276,12 @@ 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)
+        default_settings = DefaultSettingsSource(
+            self.__class__, default_objects_copy_by_value=default_objects_copy_by_value
+        )
+        init_settings = InitSettingsSource(
+            self.__class__, init_kwargs=init_kwargs, default_objects_copy_by_value=default_objects_copy_by_value
+        )
         env_settings = EnvSettingsSource(
             self.__class__,
             case_sensitive=case_sensitive,
@@ -344,6 +359,7 @@ def _settings_build_values(
         validate_default=True,
         case_sensitive=False,
         env_prefix='',
+        default_objects_copy_by_value=False,
         env_file=None,
         env_file_encoding=None,
         env_ignore_empty=False,

pydantic_settings/sources.py

@@ -10,14 +10,15 @@
 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
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     Generic,
     Iterator,
     List,
@@ -34,8 +35,9 @@
 
 import typing_extensions
 from dotenv import dotenv_values
-from pydantic import AliasChoices, AliasPath, BaseModel, Json
+from pydantic import AliasChoices, AliasPath, BaseModel, Json, TypeAdapter
 from pydantic._internal._repr import Representation
+from pydantic._internal._signature import _field_name_for_signature
 from pydantic._internal._typing_extra import WithArgsTypes, origin_is_union, typing_base
 from pydantic._internal._utils import deep_update, is_model_class, lenient_issubclass
 from pydantic.dataclasses import is_pydantic_dataclass
@@ -248,55 +250,23 @@ def __call__(self) -> dict[str, Any]:
 
 class DefaultSettingsSource(PydanticBaseSettingsSource):
     """
-    Source class for loading default values.
+    Source class for loading default object values.
     """
 
-    def __init__(self, settings_cls: type[BaseSettings]):
+    def __init__(self, settings_cls: type[BaseSettings], default_objects_copy_by_value: bool | None = None):
         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):
-                        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]
+        self.defaults: dict[str, Any] = {}
+        self.default_objects_copy_by_value = (
+            default_objects_copy_by_value
+            if default_objects_copy_by_value is not None
+            else self.config.get('default_objects_copy_by_value', False)
+        )
+        if self.default_objects_copy_by_value:
+            for field_name, field_info in settings_cls.model_fields.items():
+                if is_dataclass(type(field_info.default)):
+                    self.defaults[_field_name_for_signature(field_name, field_info)] = asdict(field_info.default)
+                elif is_model_class(type(field_info.default)):
+                    self.defaults[_field_name_for_signature(field_name, field_info)] = field_info.default.model_dump()
 
     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
@@ -306,27 +276,44 @@ def __call__(self) -> dict[str, Any]:
         return self.defaults
 
     def __repr__(self) -> str:
-        return 'DefaultSettingsSource()'
+        return f'DefaultSettingsSource(default_objects_copy_by_value={self.default_objects_copy_by_value})'
 
 
 class InitSettingsSource(PydanticBaseSettingsSource):
     """
     Source class for loading values provided during settings class initialization.
     """
 
-    def __init__(self, settings_cls: type[BaseSettings], init_kwargs: dict[str, Any]):
+    def __init__(
+        self,
+        settings_cls: type[BaseSettings],
+        init_kwargs: dict[str, Any],
+        default_objects_copy_by_value: bool | None = None,
+    ):
         self.init_kwargs = init_kwargs
         super().__init__(settings_cls)
+        self.default_objects_copy_by_value = (
+            default_objects_copy_by_value
+            if default_objects_copy_by_value is not None
+            else self.config.get('default_objects_copy_by_value', False)
+        )
 
     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.init_kwargs
+        return (
+            TypeAdapter(Dict[str, Any]).dump_python(self.init_kwargs)
+            if self.default_objects_copy_by_value
+            else self.init_kwargs
+        )
 
     def __repr__(self) -> str:
-        return f'InitSettingsSource(init_kwargs={self.init_kwargs!r})'
+        return (
+            f'InitSettingsSource(init_kwargs={self.init_kwargs!r}, '
+            f'default_objects_copy_by_value={self.default_objects_copy_by_value})'
+        )
 
 
 class PydanticBaseEnvSettingsSource(PydanticBaseSettingsSource):

tests/test_settings.py

@@ -49,7 +49,13 @@
     TomlConfigSettingsSource,
     YamlConfigSettingsSource,
 )
-from pydantic_settings.sources import CliPositionalArg, CliSettingsSource, CliSubCommand, SettingsError
+from pydantic_settings.sources import (
+    CliPositionalArg,
+    CliSettingsSource,
+    CliSubCommand,
+    DefaultSettingsSource,
+    SettingsError,
+)
 
 try:
     import dotenv
@@ -491,24 +497,78 @@ class ComplexSettings(BaseSettings):
     ]
 
 
-def test_env_default_settings(env):
+def test_class_default_objects_copy_by_value(env):
     class NestedA(BaseModel):
         v0: bool
         v1: bool
 
-    class NestedB(BaseModel):
+    @pydantic_dataclasses.dataclass
+    class NestedB:
+        v0: bool
+        v1: bool
+
+    @dataclasses.dataclass
+    class NestedC:
+        v0: bool
+        v1: bool
+
+    class NestedD(BaseModel):
         v0: bool = False
         v1: bool = True
 
-    class SettingsDefaultsA(BaseSettings, env_nested_delimiter='__'):
-        nested: NestedB = NestedB()
+    class SettingsDefaultsA(BaseSettings, env_nested_delimiter='__', default_objects_copy_by_value=True):
+        nested_a: NestedA = NestedA(v0=False, v1=True)
+        nested_b: NestedB = NestedB(v0=False, v1=True)
+        nested_d: NestedC = NestedC(v0=False, v1=True)
+        nested_c: NestedD = NestedD()
+
+    env.set('NESTED_A__V0', 'True')
+    env.set('NESTED_B__V0', 'True')
+    env.set('NESTED_C__V0', 'True')
+    env.set('NESTED_D__V0', 'True')
+    assert SettingsDefaultsA().model_dump() == {
+        'nested_a': {'v0': True, 'v1': True},
+        'nested_b': {'v0': True, 'v1': True},
+        'nested_c': {'v0': True, 'v1': True},
+        'nested_d': {'v0': True, 'v1': True},
+    }
 
-    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_init_kwargs_default_objects_copy_by_value(env):
+    class DeepSubModel(BaseModel):
+        v4: str
+
+    class SubModel(BaseModel):
+        v1: str
+        v2: bytes
+        v3: int
+        deep: DeepSubModel
+
+    class Settings(BaseSettings, env_nested_delimiter='__', default_objects_copy_by_value=True):
+        v0: str
+        sub_model: SubModel
+
+        @classmethod
+        def settings_customise_sources(
+            cls, settings_cls, init_settings, env_settings, dotenv_settings, file_secret_settings
+        ):
+            return env_settings, dotenv_settings, init_settings, file_secret_settings
+
+    env.set('SUB_MODEL__DEEP__V4', 'override-v4')
+
+    s_final = {'v0': '0', 'sub_model': {'v1': 'init-v1', 'v2': b'init-v2', 'v3': 3, 'deep': {'v4': 'override-v4'}}}
+
+    s = Settings(v0='0', sub_model={'v1': 'init-v1', 'v2': b'init-v2', 'v3': 3, 'deep': {'v4': 'init-v4'}})
+    assert s.model_dump() == s_final
+
+    s = Settings(v0='0', sub_model=SubModel(v1='init-v1', v2=b'init-v2', v3=3, deep=DeepSubModel(v4='init-v4')))
+    assert s.model_dump() == s_final
+
+    s = Settings(v0='0', sub_model=SubModel(v1='init-v1', v2=b'init-v2', v3=3, deep={'v4': 'init-v4'}))
+    assert s.model_dump() == s_final
+
+    s = Settings(v0='0', sub_model={'v1': 'init-v1', 'v2': b'init-v2', 'v3': 3, 'deep': DeepSubModel(v4='init-v4')})
+    assert s.model_dump() == s_final
 
 
 def test_env_str(env):
@@ -1569,9 +1629,13 @@ def settings_customise_sources(cls, *args, **kwargs):
 
 
 def test_builtins_settings_source_repr():
+    assert (
+        repr(DefaultSettingsSource(BaseSettings, default_objects_copy_by_value=True))
+        == 'DefaultSettingsSource(default_objects_copy_by_value=True)'
+    )
     assert (
         repr(InitSettingsSource(BaseSettings, init_kwargs={'apple': 'value 0', 'banana': 'value 1'}))
-        == "InitSettingsSource(init_kwargs={'apple': 'value 0', 'banana': 'value 1'})"
+        == "InitSettingsSource(init_kwargs={'apple': 'value 0', 'banana': 'value 1'}, default_objects_copy_by_value=False)"
     )
     assert (
         repr(EnvSettingsSource(BaseSettings, env_nested_delimiter='__'))