Fix AttributeError with nested env vars for dict fields (#785) (#786)

hramezani · claude · web-flow · commit 58b236a36473 · 2026-02-18T08:20:32.000Z
Co-authored-by: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/pydantic_settings/sources/providers/env.py b/pydantic_settings/sources/providers/env.py
@@ -21,6 +21,7 @@
 from ..utils import (
     _annotation_contains_types,
     _annotation_enum_name_to_val,
+    _annotation_is_complex,
     _get_model_fields,
     _union_is_complex,
     parse_env_vars,
@@ -209,7 +210,7 @@ class Cfg(BaseSettings):
                         return f
         return None
 
-    def explode_env_vars(self, field_name: str, field: FieldInfo, env_vars: Mapping[str, str | None]) -> dict[str, Any]:
+    def explode_env_vars(self, field_name: str, field: FieldInfo, env_vars: Mapping[str, str | None]) -> dict[str, Any]:  # noqa: C901
         """
         Process env_vars and extract the values of keys containing env_nested_delimiter into nested dictionaries.
 
@@ -253,17 +254,22 @@ def explode_env_vars(self, field_name: str, field: FieldInfo, env_vars: Mapping[
 
             # check if env_val maps to a complex field and if so, parse the env_val
             if (target_field or is_dict) and env_val:
-                if target_field:
+                if isinstance(target_field, FieldInfo):
                     is_complex, allow_json_failure = self._field_is_complex(target_field)
                     if self.env_parse_enums:
                         enum_val = _annotation_enum_name_to_val(target_field.annotation, env_val)
                         env_val = env_val if enum_val is None else enum_val
+                elif target_field:
+                    # target_field is a raw type (e.g. from dict value type annotation)
+                    is_complex = _annotation_is_complex(target_field, [])
+                    allow_json_failure = True
                 else:
                     # nested field type is dict
                     is_complex, allow_json_failure = True, True
                 if is_complex:
                     try:
-                        env_val = self.decode_complex_value(last_key, target_field, env_val)  # type: ignore
+                        field_info = target_field if isinstance(target_field, FieldInfo) else None
+                        env_val = self.decode_complex_value(last_key, field_info, env_val)  # type: ignore
                     except ValueError as e:
                         if not allow_json_failure:
                             raise e
diff --git a/tests/test_settings.py b/tests/test_settings.py
@@ -2855,6 +2855,49 @@ class Settings(BaseSettings):
     assert s.model_dump() == {'nested': {'foo': {'a': {'b': 'bar'}}}}
 
 
+def test_env_nested_dict_simple_value_types(env):
+    """Test that nested env vars work for dict fields with simple value types (e.g. dict[str, str]).
+
+    Regression test for https://github.com/pydantic/pydantic-settings/issues/785
+    """
+
+    class Settings(BaseSettings):
+        nested_field: dict[str, str]
+
+        model_config = SettingsConfigDict(env_nested_delimiter='__')
+
+    env.set('nested_field__key', 'some value')
+    s = Settings()
+    assert s.model_dump() == {'nested_field': {'key': 'some value'}}
+
+
+def test_env_nested_dict_multiple_simple_keys(env):
+    """Test multiple nested env vars for dict[str, str]."""
+
+    class Settings(BaseSettings):
+        nested_field: dict[str, str]
+
+        model_config = SettingsConfigDict(env_nested_delimiter='__')
+
+    env.set('nested_field__key1', 'value1')
+    env.set('nested_field__key2', 'value2')
+    s = Settings()
+    assert s.model_dump() == {'nested_field': {'key1': 'value1', 'key2': 'value2'}}
+
+
+def test_env_nested_dict_complex_value_type(env):
+    """Test nested env vars for dict with complex value types like list[str]."""
+
+    class Settings(BaseSettings):
+        nested_field: dict[str, list[str]]
+
+        model_config = SettingsConfigDict(env_nested_delimiter='__')
+
+    env.set('nested_field__key', '["a", "b"]')
+    s = Settings()
+    assert s.model_dump() == {'nested_field': {'key': ['a', 'b']}}
+
+
 def test_nested_models_leaf_vs_deeper_env_dict_assumed(env):
     class NestedSettings(BaseModel):
         foo: str
