fix(fields): handle properly default value for type Callable

changes/1596-PrettyWood.md

@@ -0,0 +1 @@
+Handle properly default value for fields of type `Callable`

pydantic/main.py

@@ -198,7 +198,8 @@ def validate_custom_root_type(fields: Dict[str, ModelField]) -> None:
         raise ValueError('__root__ cannot be mixed with other fields')
 
 
-UNTOUCHED_TYPES = FunctionType, property, type, classmethod, staticmethod
+FIELD_DEFAULT_VALUE_UNTOUCHED_TYPES = property, type, classmethod, staticmethod
+UNTOUCHED_TYPES = (FunctionType,) + FIELD_DEFAULT_VALUE_UNTOUCHED_TYPES
 
 # Note `ModelMetaclass` refers to `BaseModel`, but is also used to *create* `BaseModel`, so we need to add this extra
 # (somewhat hacky) boolean to keep track of whether we've created the `BaseModel` class yet, and therefore whether it's
@@ -245,7 +246,6 @@ def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
         class_vars = set()
         if (namespace.get('__module__'), namespace.get('__qualname__')) != ('pydantic.main', 'BaseModel'):
             annotations = resolve_annotations(namespace.get('__annotations__', {}), namespace.get('__module__', None))
-            untouched_types = UNTOUCHED_TYPES + config.keep_untouched
             # annotation only fields need to come first in fields
             for ann_name, ann_type in annotations.items():
                 if is_classvar(ann_type):
@@ -254,7 +254,7 @@ def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
                     validate_field_name(bases, ann_name)
                     value = namespace.get(ann_name, Undefined)
                     if (
-                        isinstance(value, untouched_types)
+                        isinstance(value, FIELD_DEFAULT_VALUE_UNTOUCHED_TYPES)
                         and ann_type != PyObject
                         and not lenient_issubclass(get_origin(ann_type), Type)
                     ):
@@ -269,6 +269,7 @@ def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
                 elif ann_name not in namespace and config.underscore_attrs_are_private:
                     private_attributes[ann_name] = PrivateAttr()
 
+            untouched_types = UNTOUCHED_TYPES + config.keep_untouched
             for var_name, value in namespace.items():
                 can_be_changed = var_name not in class_vars and not isinstance(value, untouched_types)
                 if isinstance(value, ModelPrivateAttr):

tests/test_main.py

@@ -1,4 +1,5 @@
 import sys
+from dataclasses import dataclass as stdlib_dataclass, field
 from enum import Enum
 from typing import Any, Callable, ClassVar, Dict, List, Mapping, Optional, Type, get_type_hints
 from uuid import UUID, uuid4
@@ -18,6 +19,7 @@
     root_validator,
     validator,
 )
+from pydantic.dataclasses import dataclass as pydantic_dataclass
 from pydantic.typing import Literal
 
 
@@ -1374,3 +1376,47 @@ class M(BaseModel):
         a: int
 
     get_type_hints(M.__config__)
+
+
+def foo(arg1, arg2):
+    return arg1, arg2
+
+
+@pydantic_dataclass
+class HasCallablesDC:
+    non_default_callable: Callable
+    default_callable: Callable = lambda x: foo(x, 'default')
+    default_callable_factory: Callable = field(default=lambda x: foo(x, 'factory'))
+
+
+class HasCallablesModel(BaseModel):
+    non_default_callable: Callable
+    default_callable: Callable = lambda x: foo(x, 'default')
+    default_callable_factory: Callable = Field(default_factory=lambda: lambda x: foo(x, 'factory'))
+
+
+@stdlib_dataclass
+class HasCallablesStdlibDC:
+    non_default_callable: Callable
+    default_callable: Callable = lambda x: foo(x, 'default')
+    default_callable_factory: Callable = field(default_factory=lambda: lambda x: foo(x, 'factory'))
+
+
+@pytest.mark.parametrize('cls', [HasCallablesModel, HasCallablesDC])
+def test_pydantic_callable_field(cls):
+    """pydantic callable fields behaviour should be the same as stdlib dataclass"""
+
+    def non_default_callable(x):
+        return foo(x, 'nondefault')
+
+    a1 = cls(non_default_callable=non_default_callable)
+    a2 = HasCallablesStdlibDC(non_default_callable=non_default_callable)
+
+    # call non_default
+    assert a1.non_default_callable('hello') == a2.non_default_callable('hello')
+
+    # call default_factory
+    assert a1.default_callable_factory('hello') == a2.default_callable_factory('hello')
+
+    # call default
+    assert a1.default_callable('hello') == a2.default_callable('hello')