FastAPI: Receiving and Validating Nested JSON with Custom Data Types
I'm stuck on something that should probably be simple. I'm relatively new to this, so bear with me. I'm building an API using FastAPI (version 0.75.0) that needs to accept a nested JSON structure. The JSON includes custom data types such as a date string that I want to convert to a Python `datetime.date` object. However, I'm running into issues with validation when FastAPI tries to parse nested structures. Here's a simplified version of my code: ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel, validator from datetime import date class Event(BaseModel): name: str date: str # initially a string to be converted @validator('date') def validate_date(cls, v): try: return date.fromisoformat(v) except ValueError: raise ValueError('Invalid date format, expected YYYY-MM-DD') class User(BaseModel): username: str events: List[Event] app = FastAPI() @app.post('/users/') async def create_user(user: User): return user ``` When I send a POST request with the following JSON: ```json { "username": "test_user", "events": [ {"name": "Birthday Party", "date": "2023-12-01"}, {"name": "Conference", "date": "invalid-date"} ] } ``` I receive the following behavior: ``` "detail": [{"loc": ["body", "events", 1, "date"], "msg": "Invalid date format, expected YYYY-MM-DD", "type": "value_error"}] ``` I expected the validation to catch the invalid date and return a more user-friendly behavior message, but it seems to be causing the entire request to unexpected result. I've also tried using the `@root_validator` instead of a standard validator, but that approach was even less effective. How can I structure my validation in a way that allows for clearer behavior messaging while still validating nested data correctly? Also, is there a way to disable validation for specific cases based on conditions? Thanks in advance for any suggestions! My development environment is Linux. Is there a better approach? Am I approaching this the right way? Thanks in advance!