How to implement a fallback/default value when validation fails?

[plutaniano]

SuccessfulStatusCode = Annotated[int, Field(ge=200, le=299)]

class Model(BaseModel):
    status_code: SuccessfulStatusCode = 200

Model(status_code=204)  # returns Model(status_code=204)
Model(status_code=500)  # Error
Model()  # returns Model(status_code=200)

Is there a way to elegantly implement a default/fallback value that is used when pydantic can't validate the value?

I want this behavior:

Model(status_code="literally anything not in [200, 300)")  # returns Model(status_code=200)

[drorata]

Using a field_validator it is possible to solve the problem. BUT, I find this solution rather ugly and hard to maintain. For example, the boundaries of the allowed values need to be manually duplicated in the code. I am unaware of a better solution :(

SuccessfulStatusCode = Annotated[int, Field(ge=200, le=299)]

class Model(BaseModel):
    status_code: SuccessfulStatusCode = 200

    @field_validator("status_code", mode="before")
    @classmethod
    def validate_status_code(cls, v: int) -> int:
        if v < 200 or v > 299:
            return 200
        return v

Model(status_code=204)  # returns Model(status_code=204)
Model(status_code=500)  # Error
Model()  # returns Model(status_code=200)

N.B.

By implementing a dummy model, you can make it a little nicer:

class DummyEmail(BaseModel):
    e: EmailStr


class Foo(BaseModel):
    e: EmailStr | None = None
    some_other_field: str = None

    @field_validator("e", mode="before")
    @classmethod
    def validate_email(cls, v):
        
        v = v.replace(" <at> ", "@")

        try:
            DummyEmail(e=v)
        except ValidationError:
            return None
        return v

[plutaniano]

I ended up implementing it like this:

from typing import Annotated, Any

from pydantic import BaseModel, Field, ValidationInfo, ValidatorFunctionWrapHandler
from pydantic.functional_validators import WrapValidator


def Fallback(fallback_value: Any):
    def use_fallback(
        v: Any,
        handler: ValidatorFunctionWrapHandler,
        info: ValidationInfo,
    ) -> Any:
        try:
            return handler(v)
        except ValueError:
            return fallback_value

    return WrapValidator(use_fallback)


SuccessfulStatusCode = Annotated[int, Field(ge=200, le=299), Fallback(200)]


class Model(BaseModel):
    status_code: SuccessfulStatusCode


assert Model(status_code=-1).status_code == 200

[ybressler]

This is an elegant solution. Perhaps worth including as a feature request?