Deprecate field_name argument on core_schema.with_info_{before,after,plain,wrap}_validator_function

Author: DouweM

python/pydantic_core/core_schema.py

@@ -1954,7 +1954,7 @@ class NoInfoValidatorFunctionSchema(TypedDict):
 class WithInfoValidatorFunctionSchema(TypedDict, total=False):
     type: Required[Literal['with-info']]
     function: Required[WithInfoValidatorFunction]
-    field_name: str
+    field_name: str  # deprecated
 
 
 ValidationFunction = Union[NoInfoValidatorFunctionSchema, WithInfoValidatorFunctionSchema]
@@ -2042,7 +2042,7 @@ def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
         return v.decode() + 'world'
 
     func_schema = core_schema.with_info_before_validator_function(
-        function=fn, schema=core_schema.str_schema(), field_name='a'
+        function=fn, schema=core_schema.str_schema()
     )
     schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
 
@@ -2052,13 +2052,19 @@ def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
 
     Args:
         function: The validator function to call
-        field_name: The name of the field
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         schema: The schema to validate the output of the validator function
         ref: optional unique identifier of the schema, used to reference the schema in other places
         json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+        )
+
     return _dict_not_none(
         type='function-before',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
@@ -2140,7 +2146,7 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
         return v + 'world'
 
     func_schema = core_schema.with_info_after_validator_function(
-        function=fn, schema=core_schema.str_schema(), field_name='a'
+        function=fn, schema=core_schema.str_schema()
     )
     schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
 
@@ -2151,11 +2157,17 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
     Args:
         function: The validator function to call after the schema is validated
         schema: The schema to validate before the validator function
-        field_name: The name of the field this validators is applied to, if any
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+        )
+
     return _dict_not_none(
         type='function-after',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
@@ -2287,12 +2299,18 @@ def fn(
     Args:
         function: The validator function to call
         schema: The schema to validate the output of the validator function
-        field_name: The name of the field this validators is applied to, if any
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+        )
+
     return _dict_not_none(
         type='function-wrap',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
@@ -2379,12 +2397,18 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
 
     Args:
         function: The validator function to call
-        field_name: The name of the field this validators is applied to, if any
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         ref: optional unique identifier of the schema, used to reference the schema in other places
         json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+        )
+
     return _dict_not_none(
         type='function-plain',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),

tests/benchmarks/test_micro_benchmarks.py

@@ -1348,7 +1348,7 @@ def f(v: int, info: core_schema.ValidationInfo) -> int:
     limit = pydantic_core._pydantic_core._recursion_limit - 3
 
     for _ in range(limit):
-        schema = core_schema.with_info_after_validator_function(f, schema, field_name='x')
+        schema = core_schema.with_info_after_validator_function(f, schema)
 
     schema = core_schema.typed_dict_schema({'x': core_schema.typed_dict_field(schema)})
 

tests/validators/test_dataclasses.py

@@ -506,9 +506,7 @@ def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_after_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_after_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -540,7 +538,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> str:
             [
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
-                    name='b', schema=core_schema.with_info_plain_validator_function(Foo.validate_b, field_name='b')
+                    name='b', schema=core_schema.with_info_plain_validator_function(Foo.validate_b)
                 ),
             ],
         ),
@@ -573,9 +571,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_before_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_before_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -612,9 +608,7 @@ def validate_b(
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_wrap_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_wrap_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -649,9 +643,7 @@ def validate_b(
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_wrap_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_wrap_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -878,9 +870,7 @@ def func(x, info):
                     core_schema.dataclass_field('field_a', core_schema.str_schema()),
                     core_schema.dataclass_field(
                         'field_b',
-                        core_schema.with_info_after_validator_function(
-                            func, core_schema.int_schema(), field_name='field_b'
-                        ),
+                        core_schema.with_info_after_validator_function(func, core_schema.int_schema()),
                     ),
                     core_schema.dataclass_field('field_c', core_schema.int_schema()),
                 ],
@@ -1295,9 +1285,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_before_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_before_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -1332,9 +1320,7 @@ def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_after_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_after_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -1550,15 +1536,9 @@ def _wrap_validator(cls, v, validator, info):
 
         field_schema = core_schema.int_schema()
         if validator == 'field':
-            field_schema = core_schema.with_info_before_validator_function(
-                Dataclass._validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_wrap_validator_function(
-                Dataclass._wrap_validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_after_validator_function(
-                Dataclass._validator, field_schema, field_name='a'
-            )
+            field_schema = core_schema.with_info_before_validator_function(Dataclass._validator, field_schema)
+            field_schema = core_schema.with_info_wrap_validator_function(Dataclass._wrap_validator, field_schema)
+            field_schema = core_schema.with_info_after_validator_function(Dataclass._validator, field_schema)
 
         dataclass_schema = core_schema.dataclass_schema(
             Dataclass,

tests/validators/test_function.py

@@ -605,7 +605,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.with_info_before_validator_function(f, core_schema.str_schema(), field_name='x')
+                        core_schema.with_info_before_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -631,7 +631,7 @@ def f(input_value: str, info: core_schema.ValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='x')
+                        core_schema.with_info_after_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -655,7 +655,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
         core_schema.model_schema(
             Model,
             core_schema.model_fields_schema(
-                {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f, field_name='x'))}
+                {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f))}
             ),
         )
     )
@@ -674,7 +674,10 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     # When a type alias with a validator function is used on multiple fields,
     # its core schema is only generated once (with the first field_name) and reused.
     # See https://github.com/pydantic/pydantic/issues/11737
-    validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+    with pytest.warns(
+        DeprecationWarning, match='`field_name` argument on `with_info_plain_validator_function` is deprecated'
+    ):
+        validator = core_schema.with_info_plain_validator_function(f, field_name='x')
 
     v = SchemaValidator(
         core_schema.model_schema(
@@ -709,7 +712,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.with_info_wrap_validator_function(f, core_schema.str_schema(), field_name='x')
+                        core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -833,7 +836,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
                 'a': core_schema.typed_dict_field(core_schema.int_schema()),
                 'b': core_schema.typed_dict_field(core_schema.int_schema()),
                 'c': core_schema.typed_dict_field(
-                    core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='c')
+                    core_schema.with_info_after_validator_function(f, core_schema.str_schema())
                 ),
             }
         )
@@ -858,7 +861,10 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     # When a type alias with a validator function is used on multiple fields,
     # its core schema is only generated once (with the first field_name) and reused.
     # See https://github.com/pydantic/pydantic/issues/11737
-    validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+    with pytest.warns(
+        DeprecationWarning, match='`field_name` argument on `with_info_plain_validator_function` is deprecated'
+    ):
+        validator = core_schema.with_info_plain_validator_function(f, field_name='x')
 
     v = SchemaValidator(
         core_schema.typed_dict_schema(
@@ -886,7 +892,10 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     # When a type alias with a validator function is used on multiple fields,
     # its core schema is only generated once (with the first field_name) and reused.
     # See https://github.com/pydantic/pydantic/issues/11737
-    validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+    with pytest.warns(
+        DeprecationWarning, match='`field_name` argument on `with_info_plain_validator_function` is deprecated'
+    ):
+        validator = core_schema.with_info_plain_validator_function(f, field_name='x')
 
     v = SchemaValidator(
         core_schema.dataclass_schema(
@@ -1002,35 +1011,6 @@ def f_w(v: Any, handler: core_schema.ValidatorFunctionWrapHandler, info: core_sc
     calls.clear()
 
 
-def test_reprs() -> None:
-    reprs: list[str] = []
-
-    def sample_repr(v: Any, info: core_schema.ValidationInfo) -> Any:
-        reprs.append(repr(info))
-        return v
-
-    v = SchemaValidator(
-        core_schema.chain_schema(
-            [
-                core_schema.with_info_plain_validator_function(sample_repr),
-                core_schema.with_info_plain_validator_function(sample_repr, field_name='x'),
-            ]
-        )
-    )
-
-    class Foo:
-        def __repr__(self) -> str:
-            return 'This is Foo!'
-
-    v.validate_python(Foo())
-
-    # insert_assert(reprs)
-    assert reprs == [
-        'ValidationInfo(config=None, context=None, data=None, field_name=None)',
-        "ValidationInfo(config=None, context=None, data=None, field_name='x')",
-    ]
-
-
 def test_function_after_doesnt_change_mode() -> None:
     # https://github.com/pydantic/pydantic/issues/7468 - function-after was
     # incorrectly forcing Python validation mode

tests/validators/test_model.py

@@ -1054,9 +1054,7 @@ def func(x, info):
                 {
                     'field_a': core_schema.model_field(core_schema.str_schema()),
                     'field_b': core_schema.model_field(
-                        core_schema.with_info_after_validator_function(
-                            func, core_schema.int_schema(), field_name='field_b'
-                        )
+                        core_schema.with_info_after_validator_function(func, core_schema.int_schema())
                     ),
                     'field_c': core_schema.model_field(core_schema.int_schema()),
                 }

tests/validators/test_model_init.py

@@ -430,15 +430,9 @@ def _wrap_validator(cls, v, validator, info):
 
         field_schema = core_schema.int_schema()
         if validator == 'field':
-            field_schema = core_schema.with_info_before_validator_function(
-                Model._validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_wrap_validator_function(
-                Model._wrap_validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_after_validator_function(
-                Model._validator, field_schema, field_name='a'
-            )
+            field_schema = core_schema.with_info_before_validator_function(Model._validator, field_schema)
+            field_schema = core_schema.with_info_wrap_validator_function(Model._wrap_validator, field_schema)
+            field_schema = core_schema.with_info_after_validator_function(Model._validator, field_schema)
 
         model_schema = core_schema.model_schema(
             Model, core_schema.model_fields_schema({'a': core_schema.model_field(field_schema)})

tests/validators/test_model_root.py

@@ -138,7 +138,7 @@ def f(input_value: str, info):
     v = SchemaValidator(
         core_schema.model_schema(
             RootModel,
-            core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='root'),
+            core_schema.with_info_after_validator_function(f, core_schema.str_schema()),
             root_model=True,
         )
     )