Custom validation with validator decorator in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the @validator decorator in FastAPI's Pydantic models?

The @validator decorator is used to add custom validation logic to model fields. It lets you check or modify field values before the model is created.

intermediate

How do you apply a validator to multiple fields using the @validator decorator?

You pass a list of field names to the @validator decorator. The decorated method will run for each of those fields.

beginner

What should a validator method return in FastAPI's Pydantic model?

A validator method must return the validated (and possibly modified) value for the field. Returning the wrong type or nothing will cause errors.

intermediate

Can you explain the difference between @validator and @root_validator in FastAPI?

@validator validates individual fields, while @root_validator validates the whole model at once, allowing checks involving multiple fields.

beginner

What happens if a validator raises a ValueError in FastAPI?

Raising a ValueError inside a validator stops model creation and returns a clear error message to the user, explaining what went wrong.

What does the @validator decorator in FastAPI do?

A Adds custom validation logic to model fields

B Creates database tables automatically

C Handles HTTP requests

D Generates API documentation

The @validator decorator is specifically for adding custom validation to fields in Pydantic models used by FastAPI.

How do you specify which fields a validator should apply to?

A By setting a global config

B By naming the validator method after the field

C By passing field names as arguments to <code>@validator</code>

D By using <code>@root_validator</code>

You list the field names inside the @validator decorator to apply the validator to those fields.

What must a validator method return?

A Nothing

B The validated or modified field value

C A boolean true or false

D A new model instance

Validator methods must return the value that will be set on the field after validation.

Which validator type checks multiple fields together?

A @root_validator

B @validator

C @field_validator

D @model_validator

@root_validator runs after all fields are validated and can check relationships between fields.

What happens if a validator raises a ValueError?

A The server crashes

B The error is ignored

C The field is set to None

D Model creation fails with an error message

Raising ValueError stops model creation and returns a clear validation error to the client.

Explain how to create a custom validator for a Pydantic model field using the @validator decorator in FastAPI.

Think about how you check and fix data before saving it.

Describe the difference between @validator and @root_validator in FastAPI's Pydantic models.

One works on one field, the other on the whole form.

Practice

1. What is the main purpose of using the @validator decorator in a Pydantic model within FastAPI?

easy

A. To define database relationships

B. To automatically generate API routes

C. To add custom validation logic for model fields

D. To format the output JSON response

Solution

1. Step 1: Understand the role of @validator

   The @validator decorator is used inside Pydantic models to add custom validation logic for fields.

2. Step 2: Differentiate from other functionalities

   It does not generate routes, define database relations, or format output JSON; those are handled elsewhere.

3. Final Answer:

   To add custom validation logic for model fields -> Option C

4. Quick Check:

   Custom validation = To add custom validation logic for model fields [OK]

Hint: Remember: @validator checks field values before use [OK]

Common Mistakes:

• Confusing validation with route creation
• Thinking it formats output JSON
• Assuming it manages database relations

2. Which of the following is the correct syntax to create a validator for the field email in a Pydantic model?

easy

A. @validator['email']\ndef check_email(cls, value):\n return value

B. @validate('email')\ndef check_email(cls, value):\n return value

C. @validator(email)\ndef check_email(cls, value):\n return value

D. @validator('email')\ndef check_email(cls, value):\n return value

Solution

1. Step 1: Identify correct decorator usage

   The correct decorator is @validator('field_name') with the field name as a string.

2. Step 2: Check syntax correctness

   @validator('email')\ndef check_email(cls, value):\n return value uses @validator('email') correctly; others use wrong decorator names or syntax.

3. Final Answer:

   @validator('email')\ndef check_email(cls, value):\n return value -> Option D

4. Quick Check:

   Correct decorator syntax = @validator('email')\ndef check_email(cls, value):\n return value [OK]

Hint: Use quotes around field name in @validator [OK]

Common Mistakes:

• Omitting quotes around field name
• Using wrong decorator name like @validate
• Using brackets [] instead of parentheses ()

3. Given the following Pydantic model, what will happen if you create an instance with age=15?

from pydantic import BaseModel, validator

class User(BaseModel):
    age: int

    @validator('age')
    def check_age(cls, v):
        if v < 18:
            raise ValueError('Must be at least 18')
        return v

user = User(age=15)

medium

A. A ValueError is raised with message 'Must be at least 18'

B. The user instance is created with age 15

C. The age is automatically set to 18

D. A TypeError is raised because age is int

Solution

1. Step 1: Analyze the validator logic

   The validator checks if age is less than 18 and raises a ValueError if true.

2. Step 2: Apply input value to validator

   Since age=15 is less than 18, the validator raises the error with the message.

3. Final Answer:

   A ValueError is raised with message 'Must be at least 18' -> Option A

4. Quick Check:

   Age < 18 triggers ValueError = A ValueError is raised with message 'Must be at least 18' [OK]

Hint: Validator raises error if condition fails [OK]

Common Mistakes:

• Assuming instance is created despite validation error
• Thinking age auto-corrects to 18
• Confusing ValueError with TypeError

4. Identify the error in this validator code snippet:

from pydantic import BaseModel, validator

class Product(BaseModel):
    price: float

    @validator('price')
    def check_price(value):
        if value <= 0:
            raise ValueError('Price must be positive')
        return value

medium

A. Validator decorator should be @validate

B. Missing cls parameter in validator method

C. Return statement is missing

D. Field name in decorator should be price without quotes

Solution

1. Step 1: Check validator method signature

   Validator methods must have cls as the first parameter, then the value.

2. Step 2: Identify missing parameter

   The method only has value, missing cls, causing a TypeError.

3. Final Answer:

   Missing cls parameter in validator method -> Option B

4. Quick Check:

   Validator method needs cls first = Missing cls parameter in validator method [OK]

Hint: Validator methods always start with cls, then value [OK]

Common Mistakes:

• Omitting cls parameter
• Using wrong decorator name
• Forgetting to return the value

5. You want to create a Pydantic model that validates a username field to ensure it is at least 3 characters long and contains only letters and numbers. Which validator implementation correctly achieves this?

hard

A. from pydantic import BaseModel, validator
import re

class User(BaseModel):
username: str

@validator('username')
def valid_username(cls, v):
if len(v) < 3 or not re.match(r'^[a-zA-Z0-9]+$', v):
raise ValueError('Username must be 3+ chars and alphanumeric')
return v

B. from pydantic import BaseModel, validator

class User(BaseModel):
username: str

@validator('username')
def valid_username(cls, v):
if len(v) > 3 and v.isalnum():
raise ValueError('Username must be 3+ chars and alphanumeric')
return v

C. from pydantic import BaseModel, validator

class User(BaseModel):
username: str

@validator('username')
def valid_username(cls, v):
if len(v) < 3 or not v.isalpha():
raise ValueError('Username must be 3+ chars and letters only')
return v

D. from pydantic import BaseModel, validator
import re

class User(BaseModel):
username: str

@validator('username')
def valid_username(cls, v):
if len(v) < 3 or not re.match(r'^[a-z]+$', v):
raise ValueError('Username must be 3+ chars and lowercase letters only')
return v

Solution

1. Step 1: Check length and character conditions

   The username must be at least 3 characters and only letters or numbers.

2. Step 2: Evaluate each option's validation logic

   from pydantic import BaseModel, validator import re class User(BaseModel): username: str @validator('username') def valid_username(cls, v): if len(v) < 3 or not re.match(r'^[a-zA-Z0-9]+$', v): raise ValueError('Username must be 3+ chars and alphanumeric') return v correctly checks length & uses regex to allow letters and numbers only. Others either check wrong conditions or restrict letters only.

3. Final Answer:

   Option A correctly validates username length and alphanumeric characters -> Option A

4. Quick Check:

   Length >=3 and alphanumeric = from pydantic import BaseModel, validator import re class User(BaseModel): username: str @validator('username') def valid_username(cls, v): if len(v) < 3 or not re.match(r'^[a-zA-Z0-9]+$', v): raise ValueError('Username must be 3+ chars and alphanumeric') return v [OK]

Hint: Use regex to check alphanumeric and length together [OK]

Common Mistakes:

• Using isalpha() instead of isalnum()
• Checking length incorrectly (greater than vs less than)
• Restricting to letters only when numbers allowed