remove from_attributes logic from type-dict validator

Author: samuelcolvin

pydantic_core/core_schema.py

@@ -2659,7 +2659,6 @@ class TypedDictSchema(TypedDict, total=False):
     extra_behavior: ExtraBehavior
     total: bool  # default: True
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
-    from_attributes: bool
     ref: str
     metadata: Any
     serialization: SerSchema
@@ -2674,7 +2673,6 @@ def typed_dict_schema(
     extra_behavior: ExtraBehavior | None = None,
     total: bool | None = None,
     populate_by_name: bool | None = None,
-    from_attributes: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: SerSchema | None = None,
@@ -2702,7 +2700,6 @@ def typed_dict_schema(
         extra_behavior: The extra behavior to use for the typed dict
         total: Whether the typed dict is total
         populate_by_name: Whether the typed dict should populate by name
-        from_attributes: Whether the typed dict should be populated from attributes
         serialization: Custom serialization schema
     """
     return dict_not_none(
@@ -2714,7 +2711,6 @@ def typed_dict_schema(
         extra_behavior=extra_behavior,
         total=total,
         populate_by_name=populate_by_name,
-        from_attributes=from_attributes,
         ref=ref,
         metadata=metadata,
         serialization=serialization,

src/validators/typed_dict.rs

@@ -30,7 +30,6 @@ pub struct TypedDictValidator {
     extra_behavior: ExtraBehavior,
     extra_validator: Option<Box<CombinedValidator>>,
     strict: bool,
-    from_attributes: bool,
     loc_by_alias: bool,
 }
 
@@ -47,7 +46,6 @@ impl BuildValidator for TypedDictValidator {
 
         let total =
             schema_or_config(schema, config, intern!(py, "total"), intern!(py, "typed_dict_total"))?.unwrap_or(true);
-        let from_attributes = schema_or_config_same(schema, config, intern!(py, "from_attributes"))?.unwrap_or(false);
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
@@ -119,7 +117,6 @@ impl BuildValidator for TypedDictValidator {
             extra_behavior,
             extra_validator,
             strict,
-            from_attributes,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
         }
         .into())
@@ -136,7 +133,7 @@ impl Validator for TypedDictValidator {
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let strict = extra.strict.unwrap_or(self.strict);
-        let dict = input.validate_model_fields(strict, self.from_attributes)?;
+        let dict = input.validate_dict(strict)?;
 
         let output_dict = PyDict::new(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());

tests/validators/test_definitions_recursive.py

@@ -361,10 +361,6 @@ def test_recursion_branch():
         'branch': {'name': 'b1', 'branch': None},
     }
 
-    data = Cls(name='root')
-    data.branch = Cls(name='b1', branch=None)
-    assert v.validate_python(data) == {'name': 'root', 'branch': {'name': 'b1', 'branch': None}}
-
     b = {'name': 'recursive'}
     b['branch'] = b
     with pytest.raises(ValidationError) as exc_info:
@@ -379,6 +375,40 @@ def test_recursion_branch():
         }
     ]
 
+
+def test_recursion_branch_from_attributes():
+    v = SchemaValidator(
+        {
+            'type': 'model-fields',
+            'ref': 'Branch',
+            'fields': {
+                'name': {'type': 'model-field', 'schema': {'type': 'str'}},
+                'branch': {
+                    'type': 'model-field',
+                    'schema': {
+                        'type': 'default',
+                        'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
+                        'default': None,
+                    },
+                },
+            },
+        },
+        {'from_attributes': True},
+    )
+
+    assert v.validate_python({'name': 'root'}) == ({'name': 'root', 'branch': None}, None, {'name'})
+    model_dict, model_extra, fields_set = v.validate_python({'name': 'root', 'branch': {'name': 'b1', 'branch': None}})
+    assert model_dict == {'name': 'root', 'branch': ({'name': 'b1', 'branch': None}, None, {'name', 'branch'})}
+    assert model_extra is None
+    assert fields_set == {'name', 'branch'}
+
+    data = Cls(name='root')
+    data.branch = Cls(name='b1', branch=None)
+    model_dict, model_extra, fields_set = v.validate_python(data)
+    assert model_dict == {'name': 'root', 'branch': ({'name': 'b1', 'branch': None}, None, {'name', 'branch'})}
+    assert model_extra is None
+    assert fields_set == {'name', 'branch'}
+
     data = Cls(name='root')
     data.branch = data
     with pytest.raises(ValidationError) as exc_info:

tests/validators/test_tagged_union.py

@@ -437,27 +437,35 @@ def test_from_attributes():
             'discriminator': 'foobar',
             'choices': {
                 'apple': {
-                    'type': 'typed-dict',
+                    'type': 'model-fields',
                     'fields': {
-                        'a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
+                        'a': {'type': 'model-field', 'schema': {'type': 'str'}},
+                        'b': {'type': 'model-field', 'schema': {'type': 'int'}},
                     },
                 },
                 'banana': {
-                    'type': 'typed-dict',
+                    'type': 'model-fields',
                     'fields': {
-                        'c': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'd': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
+                        'c': {'type': 'model-field', 'schema': {'type': 'str'}},
+                        'd': {'type': 'model-field', 'schema': {'type': 'int'}},
                     },
                 },
             },
         },
         {'from_attributes': True},
     )
-    assert v.validate_python({'foobar': 'apple', 'a': 'apple', 'b': '13'}) == {'a': 'apple', 'b': 13}
-    assert v.validate_python(Cls(foobar='apple', a='apple', b='13')) == {'a': 'apple', 'b': 13}
-    assert v.validate_python({'foobar': 'banana', 'c': 'banana', 'd': '31'}) == {'c': 'banana', 'd': 31}
-    assert v.validate_python(Cls(foobar='banana', c='banana', d='31')) == {'c': 'banana', 'd': 31}
+    assert v.validate_python({'foobar': 'apple', 'a': 'apple', 'b': '13'}) == (
+        {'a': 'apple', 'b': 13},
+        None,
+        {'a', 'b'},
+    )
+    assert v.validate_python(Cls(foobar='apple', a='apple', b='13')) == ({'a': 'apple', 'b': 13}, None, {'a', 'b'})
+    assert v.validate_python({'foobar': 'banana', 'c': 'banana', 'd': '31'}) == (
+        {'c': 'banana', 'd': 31},
+        None,
+        {'c', 'd'},
+    )
+    assert v.validate_python(Cls(foobar='banana', c='banana', d='31')) == ({'c': 'banana', 'd': 31}, None, {'c', 'd'})
 
 
 def test_use_ref():