pydantic · sydney-runkle · Nov 19, 2024 · Nov 17, 2024 · Nov 18, 2024 · Nov 19, 2024
diff --git a/pydantic/_internal/_model_construction.py b/pydantic/_internal/_model_construction.py
@@ -152,6 +152,8 @@ def wrapped_model_post_init(self: BaseModel, context: Any, /) -> None:
                 None if cls.model_post_init is BaseModel_.model_post_init else 'model_post_init'
             )
 
+            cls.__pydantic_setattr_handlers__ = {}
+
             cls.__pydantic_decorators__ = DecoratorInfos.build(cls)
 
             # Use the getattr below to grab the __parameters__ from the `typing.Generic` parent class

diff --git a/pydantic/main.py b/pydantic/main.py
@@ -81,6 +81,20 @@
 _object_setattr = _model_construction.object_setattr
 
 
+def _model_field_setattr_handler(model: BaseModel, name: str, val: Any) -> None:
+    model.__dict__[name] = val
+    model.__pydantic_fields_set__.add(name)
+
+
+_SIMPLE_SETATTR_HANDLERS: Mapping[str, Callable[[BaseModel, str, Any], None]] = {
+    'model_field': _model_field_setattr_handler,
+    'validate_assignment': lambda model, name, val: model.__pydantic_validator__.validate_assignment(model, name, val),  # pyright: ignore[reportAssignmentType]
+    'private': lambda model, name, val: model.__pydantic_private__.__setitem__(name, val),  # pyright: ignore[reportOptionalMemberAccess]
+    'cached_property': lambda model, name, val: model.__dict__.__setitem__(name, val),
+    'extra_known': lambda model, name, val: _object_setattr(model, name, val),
+}
+
+
 class BaseModel(metaclass=_model_construction.ModelMetaclass):
     """Usage docs: https://docs.pydantic.dev/2.10/concepts/models/
 
@@ -169,6 +183,9 @@ class BaseModel(metaclass=_model_construction.ModelMetaclass):
     This replaces `Model.__fields__` from Pydantic V1.
     """
 
+    __pydantic_setattr_handlers__: ClassVar[Dict[str, Callable[[BaseModel, str, Any], None]]]  # noqa: UP006
+    """`__setattr__` handlers. Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`"""
+
     __pydantic_computed_fields__: ClassVar[Dict[str, ComputedFieldInfo]]  # noqa: UP006
     """A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects."""
 
@@ -890,53 +907,63 @@ def __getattr__(self, item: str) -> Any:
                         raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}')
 
         def __setattr__(self, name: str, value: Any) -> None:
-            if name in self.__class_vars__:
+            if (setattr_handler := self.__pydantic_setattr_handlers__.get(name)) is not None:
+                setattr_handler(self, name, value)
+            # if None is returned from _setattr_handler, the attribute was set directly
+            elif (setattr_handler := self._setattr_handler(name, value)) is not None:
+                setattr_handler(self, name, value)  # call here to not memo on possibly unknown fields
+                self.__pydantic_setattr_handlers__[name] = setattr_handler  # memoize the handler for faster access
+
+        def _setattr_handler(self, name: str, value: Any) -> Callable[[BaseModel, str, Any], None] | None:
+            """Get a handler for setting an attribute on the model instance.
+
+            Returns:
+                A handler for setting an attribute on the model instance. Used for memoization of the handler.
+                Memoizing the handlers leads to a dramatic performance improvement in `__setattr__`
+                Returns `None` when memoization is not safe, then the attribute is set directly.
+            """
+            cls = self.__class__
+            if name in cls.__class_vars__:
                 raise AttributeError(
-                    f'{name!r} is a ClassVar of `{self.__class__.__name__}` and cannot be set on an instance. '
-                    f'If you want to set a value on the class, use `{self.__class__.__name__}.{name} = value`.'
+                    f'{name!r} is a ClassVar of `{cls.__name__}` and cannot be set on an instance. '
+                    f'If you want to set a value on the class, use `{cls.__name__}.{name} = value`.'
                 )
             elif not _fields.is_valid_field_name(name):
-                if self.__pydantic_private__ is None or name not in self.__private_attributes__:
-                    _object_setattr(self, name, value)
-                else:
-                    attribute = self.__private_attributes__[name]
+                if (attribute := cls.__private_attributes__.get(name)) is not None:
                     if hasattr(attribute, '__set__'):
-                        attribute.__set__(self, value)  # type: ignore
+                        return lambda model, _name, val: attribute.__set__(model, val)
                     else:
-                        self.__pydantic_private__[name] = value
-                return
+                        return _SIMPLE_SETATTR_HANDLERS['private']
+                else:
+                    _object_setattr(self, name, value)
+                    return None  # Can not return memoized handler with possibly freeform attr names
 
-            self._check_frozen(name, value)
+            cls._check_frozen(name, value)
 
-            attr = getattr(self.__class__, name, None)
+            attr = getattr(cls, name, None)
             # NOTE: We currently special case properties and `cached_property`, but we might need
             # to generalize this to all data/non-data descriptors at some point. For non-data descriptors
             # (such as `cached_property`), it isn't obvious though. `cached_property` caches the value
             # to the instance's `__dict__`, but other non-data descriptors might do things differently.
             if isinstance(attr, property):
-                attr.__set__(self, value)
+                return lambda model, _name, val: attr.__set__(model, val)
             elif isinstance(attr, cached_property):
-                self.__dict__[name] = value
-            elif self.model_config.get('validate_assignment', None):
-                self.__pydantic_validator__.validate_assignment(self, name, value)
-            elif self.model_config.get('extra') != 'allow' and name not in self.__pydantic_fields__:
-                # TODO - matching error
-                raise ValueError(f'"{self.__class__.__name__}" object has no field "{name}"')
-            elif self.model_config.get('extra') == 'allow' and name not in self.__pydantic_fields__:
-                if self.model_extra and name in self.model_extra:
-                    self.__pydantic_extra__[name] = value  # type: ignore
+                return _SIMPLE_SETATTR_HANDLERS['cached_property']
+            elif cls.model_config.get('validate_assignment'):
+                return _SIMPLE_SETATTR_HANDLERS['validate_assignment']
+            elif name not in cls.__pydantic_fields__:
+                if cls.model_config.get('extra') != 'allow':
+                    # TODO - matching error
+                    raise ValueError(f'"{cls.__name__}" object has no field "{name}"')
+                elif attr is None:
+                    # attribute does not exist, so put it in extra
+                    self.__pydantic_extra__[name] = value
                    return None  # Can not return memoized handler with possibly freeform attr names
                 else:
-                    try:
-                        getattr(self, name)
-                    except AttributeError:
-                        # attribute does not already exist on instance, so put it in extra
-                        self.__pydantic_extra__[name] = value  # type: ignore
-                    else:
-                        # attribute _does_ already exist on instance, and was not in extra, so update it
-                        _object_setattr(self, name, value)
+                    # attribute _does_ exist, and was not in extra, so update it
+                    return _SIMPLE_SETATTR_HANDLERS['extra_known']
             else:
-                self.__dict__[name] = value
-                self.__pydantic_fields_set__.add(name)
+                return _SIMPLE_SETATTR_HANDLERS['model_field']
 
         def __delattr__(self, item: str) -> Any:
             if item in self.__private_attributes__:
@@ -964,10 +991,11 @@ def __delattr__(self, item: str) -> Any:
                 except AttributeError:
                     raise AttributeError(f'{type(self).__name__!r} object has no attribute {item!r}')
 
-    def _check_frozen(self, name: str, value: Any) -> None:
-        if self.model_config.get('frozen', None):
+    @classmethod
+    def _check_frozen(cls, name: str, value: Any) -> None:
+        if cls.model_config.get('frozen', None):
             typ = 'frozen_instance'
-        elif getattr(self.__pydantic_fields__.get(name), 'frozen', False):
+        elif getattr(cls.__pydantic_fields__.get(name), 'frozen', False):
             typ = 'frozen_field'
         else:
             return
@@ -976,7 +1004,7 @@ def _check_frozen(self, name: str, value: Any) -> None:
             'loc': (name,),
             'input': value,
         }
-        raise pydantic_core.ValidationError.from_exception_data(self.__class__.__name__, [error])
+        raise pydantic_core.ValidationError.from_exception_data(cls.__name__, [error])
 
     def __getstate__(self) -> dict[Any, Any]:
         private = self.__pydantic_private__

diff --git a/tests/benchmarks/test_attribute_access.py b/tests/benchmarks/test_attribute_access.py
@@ -0,0 +1,84 @@
+from functools import cached_property
+
+import pytest
+
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+
+class InnerValidateAssignment(BaseModel):
+    model_config = ConfigDict(validate_assignment=True)
+    inner_field1: str
+    inner_field2: int
+
+
+class Model(BaseModel):
+    field1: str
+    field2: int
+    field3: float
+    inner1: InnerValidateAssignment
+    inner2: InnerValidateAssignment
+
+    _private_field1: str
+    _private_field2: int
+    _private_field3: float
+
+    @cached_property
+    def prop_cached1(self) -> str:
+        return self.field1 + self._private_field1
+
+    @cached_property
+    def prop_cached2(self) -> int:
+        return self.field2 + self._private_field2
+
+    @cached_property
+    def prop_cached3(self) -> float:
+        return self.field3 + self._private_field3
+
+
+def test_setattr(benchmark):
+    def set_attrs(m):
+        m.field1 = 'test1'
+        m.field2 = 43
+        m.field3 = 4.0
+        m.inner1.inner_field1 = 'test inner1'
+        m.inner1.inner_field2 = 421
+        m.inner2.inner_field1 = 'test inner2'
+        m.inner2.inner_field2 = 422
+        m._private_field1 = 'test2'
+        m._private_field2 = 44
+        m._private_field3 = 5.1
+        m.prop_cached1 = 'cache override'
+        m.prop_cached2 = 10
+        m.prop_cached3 = 10.1
+
+    inner = {'inner_field1': 'test inner', 'inner_field2': 420}
+    model = Model(field1='test', field2=42, field3=3.14, inner1=inner, inner2=inner)
+    benchmark(set_attrs, model)
+
+    model.field2 = 'bad'  # check benchmark setup
+    with pytest.raises(ValidationError):
+        model.inner1.field2 = 'bad'
+
+
+def test_getattr(benchmark):
+    def get_attrs(m):
+        _ = m.field1
+        _ = m.field2
+        _ = m.field3
+        _ = m.inner1.inner_field1
+        _ = m.inner1.inner_field2
+        _ = m.inner2.inner_field1
+        _ = m.inner2.inner_field2
+        _ = m._private_field1
+        _ = m._private_field2
+        _ = m._private_field3
+        _ = m.prop_cached1
+        _ = m.prop_cached2
+        _ = m.prop_cached3
+
+    inner = {'inner_field1': 'test inner', 'inner_field2': 420}
+    model = Model(field1='test1', field2=42, field3=3.14, inner1=inner, inner2=inner)
+    model._private_field1 = 'test2'
+    model._private_field2 = 43
+    model._private_field3 = 4.14
+    benchmark(get_attrs, model)
diff --git a/tests/test_edge_cases.py b/tests/test_edge_cases.py
@@ -2900,3 +2900,69 @@ def default_int_factory() -> int: ...
         int_factory: Callable[[], int] = Field(default=default_int_factory)
 
     assert SomeModel.model_fields['int_factory'].default is SomeModel.default_int_factory
+
+
+def test_setattr_handler_memo_does_not_inherit() -> None:
+    class Model1(BaseModel):
+        a: int
+
+    class Model2(Model1):
+        a: int
+
+    m1 = Model1(a=1)
+    m2 = Model2(a=10)
+
+    assert not Model1.__pydantic_setattr_handlers__
+    assert not Model2.__pydantic_setattr_handlers__
+
+    m2.a = 11
+    assert not Model1.__pydantic_setattr_handlers__
+    assert 'a' in Model2.__pydantic_setattr_handlers__
+    handler2 = Model2.__pydantic_setattr_handlers__['a']
+
+    m1.a = 2
+    assert 'a' in Model1.__pydantic_setattr_handlers__
+    assert Model1.__pydantic_setattr_handlers__['a'] is handler2
+    assert Model2.__pydantic_setattr_handlers__['a'] is handler2
+    assert m1.a == 2 and m2.a == 11
+
+
+def test_setattr_handler_does_not_memoize_unknown_field() -> None:
+    class Model(BaseModel):
+        a: int
+
+    m = Model(a=1)
+    with pytest.raises(ValueError, match='object has no field "unknown"'):
+        m.unknown = 'x'
+    assert not Model.__pydantic_setattr_handlers__
+    m.a = 2
+    assert 'a' in Model.__pydantic_setattr_handlers__
+
+
+def test_setattr_handler_does_not_memoize_unknown_private_field() -> None:
+    class Model(BaseModel):
+        a: int
+        _p: str
+
+    m = Model(a=1)
+    assert not Model.__pydantic_setattr_handlers__
+    m.a = 2
+    assert len(Model.__pydantic_setattr_handlers__) == 1
+    m._unknown = 'x'
+    assert len(Model.__pydantic_setattr_handlers__) == 1
+    m._p = 'y'
+    assert len(Model.__pydantic_setattr_handlers__) == 2
+
+
+def test_setattr_handler_does_not_memoize_on_validate_assignment_field_failure() -> None:
+    class Model(BaseModel, validate_assignment=True):
+        a: int
+
+    m = Model(a=1)
+    with pytest.raises(ValidationError):
+        m.unknown = 'x'
+    with pytest.raises(ValidationError):
+        m.a = 'y'
+    assert not Model.__pydantic_setattr_handlers__
+    m.a = 2
+    assert 'a' in Model.__pydantic_setattr_handlers__
diff --git a/tests/test_main.py b/tests/test_main.py
@@ -735,8 +735,12 @@ def test_validating_assignment_pass(ValidateAssignmentModel):
     assert p.model_dump() == {'a': 2, 'b': 'hi'}
 
 
-def test_validating_assignment_fail(ValidateAssignmentModel):
+@pytest.mark.parametrize('init_valid', [False, True])
+def test_validating_assignment_fail(ValidateAssignmentModel, init_valid: bool):
     p = ValidateAssignmentModel(a=5, b='hello')
+    if init_valid:
+        p.a = 5
+        p.b = 'hello'
 
     with pytest.raises(ValidationError) as exc_info:
         p.a = 'b'