@validate_arguments renamed to @validate_call
In Pydantic V2, the @validate_arguments decorator has been renamed to @validate_call.
decorators & functional api
22 notes, read out of this brain and free to use. Each one was extracted from a source and is re-checked against its exam.
@validate_call does not preserve attributes
In Pydantic V2, the @validate_call decorator does not preserve functionality from V1 such as the `raw_function` attribute or `validate()` method that could be used to validate arguments without calling the function.
validate_call decorator basic usage
The validate_call() decorator allows function arguments to be parsed and validated using the function's type annotations before the function is called. It provides an easy way to apply validation with minimal boilerplate by using the same model creation and initialization approach underneath.
validate_call parameter type inference
Parameter types are inferred from type annotations on the function, or as Any if not annotated. All types listed in the types documentation can be validated, including Pydantic models and custom types. Types are coerced by default before being passed to the actual function.
validate_call return value validation
By default, the return value of a function decorated with validate_call is not validated. To validate the return value, set the validate_return argument of the decorator to True.
validate_call supported function signatures
The validate_call() decorator works with all possible parameter configurations and combinations: positional or keyword parameters with or without defaults, keyword-only parameters (after *,), positional-only parameters (before /,), variable positional parameters (*args), and variable keyword parameters (**kwargs).
validate_call with Unpack for TypedDict
Unpack and typed dictionaries can be used to annotate variable keyword parameters of a function decorated with validate_call. This feature is available from v2.10 onwards and follows PEP 692.
validate_call with Field for parameter description
The Field() function can be used with the validate_call decorator to provide extra information and validations for function parameters. When using Field without default or default_factory parameters, the annotated pattern is recommended so type checkers infer the parameter as required. Otherwise, Field() can be used as a default value to trick type checkers into thinking a default is provided.
validate_call raw_function attribute
The original undecorated function can be accessed using the raw_function attribute on a validate_call decorated function. This is useful when you trust your input arguments and want to call the function without validation overhead for performance reasons.
validate_call with async functions
The validate_call() decorator can be applied to async functions. The same validation behavior applies, and a ValidationError is raised on validation failure for async function calls.
validate_call type checker compatibility
The validate_call() decorator preserves the decorated function's signature and should be compatible with type checkers such as mypy and pyright. However, due to Python type system limitations, the raw_function attribute and other dynamically added attributes won't be recognized by type checkers and may require suppression with # type: ignore comments.
validate_call performance considerations
The validate_call decorator has a performance impact when making calls to the decorated function compared to calling the original function. While inspection of the decorated function only happens once, the decorator is not an equivalent or alternative to function definitions in strongly typed languages. In many situations the performance impact will be negligible, but high-frequency calls should consider using raw_function when input is trusted.
validate_call with arbitrary_types_allowed example
Example: Using validate_call with arbitrary_types_allowed configuration to accept custom types. @validate_call(config=ConfigDict(arbitrary_types_allowed=True)) allows validation of function parameters that are instances of custom classes like Foobar, raising is_instance_of validation errors if incorrect types are passed.
validate_call basic example
Example showing validate_call with type coercion: @validate_call decorator on repeat(s: str, count: int, *, separator: bytes = b'') -> bytes validates that count is an integer (coercing '4' to 4) and raises ValidationError with type=int_parsing when invalid input like 'wrong' is provided.
validate_call date coercion example
Example showing type coercion with validate_call: function greater_than(d1: date, d2: date, *, include_equal=False) -> date accepts string arguments like '2000-01-01' and automatically converts them to date objects. Parameters without type annotations (like include_equal) are inferred as Any.
validate_call async function example
Example showing validate_call with async: @validate_call async def get_user_email(user_id: PositiveInt) validates PositiveInt parameter and raises ValidationError with type=greater_than when negative values like -4 are passed, with error details including loc, msg, input, ctx, and url fields.
validate_call all parameter types example
Example showing validate_call with complex function signatures: pos_or_kw (positional/keyword), kw_only (keyword-only with *,), pos_only (positional-only with /,), var_args (*args: int), var_kwargs (**kwargs: int), and armageddon combining all types (positional-only / mixed positional-keyword, *args, keyword-only, defaults, **kwargs).
validate_call Unpack TypedDict example
Example: Using validate_call with Unpack and TypedDict for **kwargs annotation. class Point(TypedDict): x: int; y: int. @validate_call def add_coords(**kwargs: Unpack[Point]) -> int: returns kwargs['x'] + kwargs['y']. Called as add_coords(x=1, y=2).
validate_call Field constraints example
Example using Field with validate_call for parameter constraints: @validate_call def how_many(num: Annotated[int, Field(gt=10)]) raises ValidationError with type=greater_than when num=1 is passed. Another example: @validate_call def return_value(value: str = Field(default='default value')) returns 'default value' when called with no arguments.
validate_call raw_function usage example
Example accessing raw_function: After @validate_call def repeat(s: str, count: int, *, separator: bytes = b''), the original function is available as repeat.raw_function('good bye', 2, separator=b', ') and returns b'good bye, good bye' without validation.
validate_call separate validation pattern
Example workaround for separating validation from function execution: @validate_call def validate_foo(a: int, b: int) returns an inner function foo() that uses the validated arguments. Calling foo = validate_foo(a=1, b=2) validates arguments, then foo() executes the logic without revalidation.
validate_call type annotations inferred as Any
When a function parameter lacks a type annotation in a validate_call decorated function, it is inferred as Any, allowing any value to pass validation.