__pydantic_extra__ None when not used

Author: samuelcolvin

pydantic_core/core_schema.py

@@ -2807,7 +2807,7 @@ def model_fields_schema(
     )
     v = SchemaValidator(wrapper_schema)
     print(v.validate_python({'a': 'hello'}))
-    #> ({'a': 'hello'}, {}, {'a'})
+    #> ({'a': 'hello'}, None, {'a'})
     ```
 
     Args:

src/validators/model.rs

@@ -133,12 +133,17 @@ impl Validator for ModelValidator {
                 let dict = input.input_get_attr(intern!(py, DUNDER_DICT)).unwrap()?;
                 let model_extra = input.input_get_attr(intern!(py, DUNDER_MODEL_EXTRA_KEY)).unwrap()?;
 
-                let full_model_dict = dict.downcast::<PyDict>()?.copy()?;
-                full_model_dict.update(model_extra.downcast()?)?;
+                let full_model_dict: &PyAny = if model_extra.is_none() {
+                    dict
+                } else {
+                    let full_model_dict = dict.downcast::<PyDict>()?.copy()?;
+                    full_model_dict.update(model_extra.downcast()?)?;
+                    full_model_dict
+                };
 
                 let output = self
                     .validator
-                    .validate(py, full_model_dict as &PyAny, extra, slots, recursion_guard)?;
+                    .validate(py, full_model_dict, extra, slots, recursion_guard)?;
 
                 let (model_dict, model_extra, _): (&PyAny, &PyAny, &PyAny) = output.extract(py)?;
                 let instance = self.create_class(model_dict, model_extra, fields_set)?;
@@ -185,7 +190,7 @@ impl Validator for ModelValidator {
             self.validator
                 .validate_assignment(py, new_dict, field_name, field_value, extra, slots, recursion_guard)?;
 
-        let (output, _, updated_fields_set): (&PyDict, &PyDict, &PySet) = output.extract(py)?;
+        let (output, _, updated_fields_set): (&PyDict, &PyAny, &PySet) = output.extract(py)?;
 
         if let Ok(fields_set) = model.input_get_attr(intern!(py, DUNDER_FIELDS_SET_KEY)).unwrap() {
             let fields_set: &PySet = fields_set.downcast()?;

src/validators/model_fields.rs

@@ -113,7 +113,7 @@ impl Validator for ModelFieldsValidator {
         let dict = input.validate_model_fields(strict, self.from_attributes)?;
 
         let model_dict = PyDict::new(py);
-        let model_extra_dict = PyDict::new(py);
+        let mut model_extra_dict_op: Option<&PyDict> = None;
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
         let mut fields_set_vec: Vec<Py<PyString>> = Vec::with_capacity(self.fields.len());
 
@@ -182,6 +182,7 @@ impl Validator for ModelFieldsValidator {
                 }
 
                 if let Some(ref mut used_keys) = used_keys {
+                    let model_extra_dict = PyDict::new(py);
                     for item_result in <$iter>::new($dict)? {
                         let (raw_key, value) = item_result?;
                         let either_str = match raw_key.strict_str() {
@@ -233,6 +234,7 @@ impl Validator for ModelFieldsValidator {
                             }
                         }
                     }
+                    model_extra_dict_op = Some(model_extra_dict);
                 }
             }};
         }
@@ -247,7 +249,7 @@ impl Validator for ModelFieldsValidator {
             Err(ValError::LineErrors(errors))
         } else {
             let fields_set = PySet::new(py, &fields_set_vec)?;
-            Ok((model_dict, model_extra_dict, fields_set).to_object(py))
+            Ok((model_dict, model_extra_dict_op, fields_set).to_object(py))
         }
     }
 
@@ -335,8 +337,7 @@ impl Validator for ModelFieldsValidator {
         }?;
 
         let fields_set: &PySet = PySet::new(py, &[field_name.to_string()])?;
-        let model_extra = PyDict::new(py);
-        Ok((new_data, model_extra, fields_set.to_object(py)).to_object(py))
+        Ok((new_data, py.None(), fields_set.to_object(py)).to_object(py))
     }
 
     fn different_strict_behavior(

tests/test_validation_context.py

@@ -132,10 +132,10 @@ def f2(input_value, info):
 
     m1, model_extra, fields_set = v.validate_python({'f1': '1', 'f2': '2'}, strict=None, context={'x': 'y'})
     assert m1 == {'f1': "1| context: {'x': 'y', 'f1': '1'}", 'f2': "2| context: {'x': 'y', 'f1': '1', 'f2': '2'}"}
-    assert model_extra == {}
+    assert model_extra is None
     assert fields_set == {'f1', 'f2'}
 
     m2, model_extra, fields_set = v.validate_assignment(m1, 'f1', '3', context={'x': 'y'})
     assert m2 == {'f1': "3| context: {'x': 'y', 'f1': '3'}", 'f2': "2| context: {'x': 'y', 'f1': '1', 'f2': '2'}"}
-    assert model_extra == {}
+    assert model_extra is None
     assert fields_set == {'f1'}

tests/validators/test_function.py

@@ -783,8 +783,8 @@ def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
         ('before', {'value': {'x': b'input', 'y': '123'}}, {'value': {'x': 'different', 'y': 123}}),
         (
             'after',
-            {'value': ({'x': 'input', 'y': 123}, {}, {'y', 'x'})},
-            {'value': ({'x': 'different', 'y': 123}, {}, {'x'})},
+            {'value': ({'x': 'input', 'y': 123}, None, {'y', 'x'})},
+            {'value': ({'x': 'different', 'y': 123}, None, {'x'})},
         ),
         ('wrap', {'value': {'x': b'input', 'y': '123'}}, {'value': {'x': 'different', 'y': 123}}),
     ],

tests/validators/test_model.py

@@ -30,7 +30,7 @@ class MyModel:
     assert isinstance(m, MyModel)
     assert m.field_a == 'test'
     assert m.field_b == 12
-    assert m.__pydantic_extra__ == {}
+    assert m.__pydantic_extra__ is None
     assert m.__pydantic_fields_set__ == {'field_a', 'field_b'}
     assert m.__dict__ == {'field_a': 'test', 'field_b': 12}
 
@@ -329,7 +329,7 @@ class MyModel:
         'foo': 'apple',
         'bar': 123,
         '__pydantic_fields_set__': {'foo', 'bar'},
-        '__pydantic_extra__': {},
+        '__pydantic_extra__': None,
     }
 
     m = v.validate_python({'foo': 'banana', 'spam': [1, 2, 3]})
@@ -339,7 +339,7 @@ class MyModel:
         'foo': 'banana',
         'spam': [1, 2, 3],
         '__pydantic_fields_set__': {'spam', 'foo'},
-        '__pydantic_extra__': {},
+        '__pydantic_extra__': None,
     }
 
 
@@ -678,7 +678,7 @@ def __init__(self, a, b, fields_set):
     ]
 
     m5 = MyModel('x', 5, None)
-    with pytest.raises(AttributeError, match="'MyModel' object has no attribute '__pydantic_fields_set__'"):
+    with pytest.raises(AttributeError, match='__pydantic_fields_set__'):
         v.validate_python(m5)
 
 
@@ -1092,8 +1092,8 @@ class MyModel:
     [
         (
             core_schema.general_after_validator_function,
-            (({'a': 1, 'b': 2}, {}, {'b'}), 'ValidationInfo(config=None, context=None)'),
-            (({'a': 10, 'b': 2}, {}, {'a'}), 'ValidationInfo(config=None, context=None)'),
+            (({'a': 1, 'b': 2}, None, {'b'}), 'ValidationInfo(config=None, context=None)'),
+            (({'a': 10, 'b': 2}, None, {'a'}), 'ValidationInfo(config=None, context=None)'),
         ),
         (
             core_schema.general_before_validator_function,
@@ -1196,7 +1196,9 @@ def __init__(self, **kwargs):
     assert m.a == 1
     assert m.b == 2
     assert m.__pydantic_fields_set__ == {'b'}
-    assert calls == ["{'validated_data': ValidatedData(model_dict={'a': 1, 'b': 2}, model_extra={}, fields_set={'b'})}"]
+    assert calls == [
+        "{'validated_data': ValidatedData(model_dict={'a': 1, 'b': 2}, model_extra=None, fields_set={'b'})}"
+    ]
 
 
 def test_custom_init_nested():
@@ -1254,7 +1256,7 @@ def __init__(self, **data):
     # insert_assert(calls)
     assert calls == [
         "outer: {'a': 2, 'b': {'b': 3}}",
-        "inner: {'validated_data': ValidatedData(model_dict={'a': 1, 'b': 3}, model_extra={}, fields_set={'b'})}",
+        "inner: {'validated_data': ValidatedData(model_dict={'a': 1, 'b': 3}, model_extra=None, fields_set={'b'})}",
     ]
 
 
@@ -1287,7 +1289,7 @@ def __init__(self, **kwargs):
 
     m = v.validate_python({'a': 2})
     assert m.a == 2
-    assert calls == ["ValidatedData(model_dict={'a': 2}, model_extra={}, fields_set={'a'})"]
+    assert calls == ["ValidatedData(model_dict={'a': 2}, model_extra=None, fields_set={'a'})"]
 
     with pytest.raises(ValidationError, match=r'Field required \[type=missing,'):
         v.validate_python({'validated_data': BadValidatedData({'a': 2}, {'a'})})
@@ -1312,7 +1314,7 @@ def __init__(self, **kwargs):
 
     m = v.validate_python({'validated_data': 2})
     assert m.validated_data == 2
-    assert calls == ["ValidatedData(model_dict={'validated_data': 2}, model_extra={}, fields_set={'validated_data'})"]
+    assert calls == ["ValidatedData(model_dict={'validated_data': 2}, model_extra=None, fields_set={'validated_data'})"]
 
     with pytest.raises(ValidationError, match='Input should be a valid integer'):
         v.validate_python({'validated_data': BadValidatedData({'a': 2}, {'a'})})