Replace model_fields

Author: hramezani

docs/index.md

@@ -2255,7 +2255,7 @@ class JsonConfigSettingsSource(PydanticBaseSettingsSource):
     def __call__(self) -> dict[str, Any]:
         d: dict[str, Any] = {}
 
-        for field_name, field in self.settings_cls.model_fields.items():
+        for field_name, field in self.settings_cls.__pydantic_fields__.items():
             field_value, field_key, value_is_complex = self.get_field_value(
                 field, field_name
             )

pydantic_settings/sources/base.py

@@ -227,7 +227,7 @@ def __init__(self, settings_cls: type[BaseSettings], nested_model_default_partia
             else self.config.get('nested_model_default_partial_update', False)
         )
         if self.nested_model_default_partial_update:
-            for field_name, field_info in settings_cls.model_fields.items():
+            for field_name, field_info in settings_cls.__pydantic_fields__.items():
                 alias_names, *_ = _get_alias_names(field_name, field_info)
                 preferred_alias = alias_names[0]
                 if is_dataclass(type(field_info.default)):
@@ -408,13 +408,13 @@ class Settings(BaseSettings):
                             break
 
             # This is here to make mypy happy
-            # Item "None" of "Optional[Type[Any]]" has no attribute "model_fields"
-            if not annotation or not hasattr(annotation, 'model_fields'):
+            # Item "None" of "Optional[Type[Any]]" has no attribute "__pydantic_fields__"
+            if not annotation or not hasattr(annotation, '__pydantic_fields__'):
                 values[name] = value
                 continue
 
             # Find field in sub model by looking in fields case insensitively
-            for sub_model_field_name, f in annotation.model_fields.items():
+            for sub_model_field_name, f in annotation.__pydantic_fields__.items():
                 if not f.validation_alias and sub_model_field_name.lower() == name.lower():
                     sub_model_field = f
                     break
@@ -470,7 +470,7 @@ def _get_resolved_field_value(self, field: FieldInfo, field_name: str) -> tuple[
     def __call__(self) -> dict[str, Any]:
         data: dict[str, Any] = {}
 
-        for field_name, field in self.settings_cls.model_fields.items():
+        for field_name, field in self.settings_cls.__pydantic_fields__.items():
             try:
                 field_value, field_key, value_is_complex = self._get_resolved_field_value(field, field_name)
             except Exception as e:

pydantic_settings/sources/providers/dotenv.py

@@ -112,7 +112,7 @@ def __call__(self) -> dict[str, Any]:
             if not env_value or env_name in data:
                 continue
             env_used = False
-            for field_name, field in self.settings_cls.model_fields.items():
+            for field_name, field in self.settings_cls.__pydantic_fields__.items():
                 for _, field_env_name, _ in self._extract_field_info(field, field_name):
                     if env_name == field_env_name or (
                         (

pydantic_settings/sources/utils.py

@@ -45,7 +45,7 @@ def _annotation_is_complex(annotation: type[Any] | None, metadata: list[Any]) ->
     # evaluate the complexity.
     if annotation is not None and _lenient_issubclass(annotation, RootModel) and annotation is not RootModel:
         annotation = cast('type[RootModel[Any]]', annotation)
-        root_annotation = annotation.model_fields['root'].annotation
+        root_annotation = annotation.__pydantic_fields__['root'].annotation
         if root_annotation is not None:
             annotation = root_annotation
 

tests/test_settings.py

@@ -1469,18 +1469,18 @@ class Settings(BaseSettings):
         foo: str = Field('default foo', validation_alias='foo_env')
         bar: str = 'bar default'
 
-    assert Settings.model_fields['bar'].alias is None
-    assert Settings.model_fields['bar'].validation_alias is None
-    assert Settings.model_fields['foo'].alias is None
-    assert Settings.model_fields['foo'].validation_alias == 'foo_env'
+    assert Settings.__pydantic_fields__['bar'].alias is None
+    assert Settings.__pydantic_fields__['bar'].validation_alias is None
+    assert Settings.__pydantic_fields__['foo'].alias is None
+    assert Settings.__pydantic_fields__['foo'].validation_alias == 'foo_env'
 
     class SubSettings(Settings):
         spam: str = 'spam default'
 
-    assert SubSettings.model_fields['bar'].alias is None
-    assert SubSettings.model_fields['bar'].validation_alias is None
-    assert SubSettings.model_fields['foo'].alias is None
-    assert SubSettings.model_fields['foo'].validation_alias == 'foo_env'
+    assert SubSettings.__pydantic_fields__['bar'].alias is None
+    assert SubSettings.__pydantic_fields__['bar'].validation_alias is None
+    assert SubSettings.__pydantic_fields__['foo'].alias is None
+    assert SubSettings.__pydantic_fields__['foo'].validation_alias == 'foo_env'
 
     assert SubSettings().model_dump() == {'foo': 'default foo', 'bar': 'bar default', 'spam': 'spam default'}
     env.set('foo_env', 'fff')
@@ -1839,7 +1839,7 @@ def __call__(self) -> dict[str, str]:
             vault_vars = vault_storage[f'{self.user}:{self.password}']
             return {
                 field_name: vault_vars[field_name]
-                for field_name in self.settings_cls.model_fields.keys()
+                for field_name in self.settings_cls.__pydantic_fields__.keys()
                 if field_name in vault_vars
             }