Can I make a default value in pydantic if None is passed in the field without using validators?

Question

Can I make a default value in pydantic if None is passed in the field without using validators?

I have the following code, but it seems to me that the validator here is superfluous for contract_ndfl. Is there any way to do without a validator?

My code:

  class User(BaseModel):
        user: int
        s_name: str
        contract_ndfl: Optional[int]
        

       @validator('contract_ndfl')
       def set_contract_ndfl(cls, v):
           return v or 13

Wishful code:

class User(BaseModel):
      user: int
      s_name: str
      contract_ndfl: Optional[int] = 13
            

Answer 1

Maybe you can use a validator for all field and define a BaseClass for it!

class NoneDefaultModel(BaseModel):

    @validator("*", pre=True)
    def not_none(cls, v, field):
        if all(
            (
                # Cater for the occasion where field.default in (0, False)
                getattr(field, "default", None) is not None,
                v is None,
            )
        ):
            return field.default
        else:
            return v

Then you can use a Subclass to Implement your wishful code:

class Bar(NoneDefaultModel):
    bar: int = 5

Bar(bar=None)
# Bar(bar=5)

Answer 2

Rather than using a validator, you can also overwrite __init__ so that the offending fields are immediately omitted:

class PreferDefaultsModel(BaseModel):
"""
Pydantic model that will use default values in place of an explicitly passed `None` value.
This is helpful when consuming APIs payloads which may explicitly define a field as `null`
rather than omitting it.
"""

def _field_allows_none(self, field_name):
    """
    Returns True if the field is exists in the model's __fields__ and it's allow_none property is True.
    Returns False otherwise.
    """
    field = self.__fields__.get(field_name)
    if field is None:
        return False
    return field.allow_none

def __init__(self, **data):
    """
    Removes any fields from the data which are None and are not allowed to be None.
    The results are then passed to the super class's init method.
    """
    data_without_null_fields = {k: v for k, v in data.items() if (
            v is not None
            or self._field_allows_none(k)
    )}
    super().__init__(**data_without_null_fields)

This can then be used in place of BaseModellike so:

class Foo(PreferDefaultsModel):
    automatic_field = 1
    explicit_field: int = Field(default=2)
    default_factory_field: int = Field(default_factory=lambda:3)
    optional_field: Optional[int] = Field(default=4)
    
f = Foo(automatic_field=None, explicit_field=None, default_factory_field=None, optional_field=None)    
print(f.json(indent=True))
{
 "explicit_field": 2,
 "default_factory_field": 3,
 "optional_field": null,
 "automatic_field": 1
}

Note that the optional field is not overwritten.

This approach will simply activate the fields' default behavior, no matter how it is defined. This is far less likely to produce unexpected results than using a validator.

Answer 3

Answer based on the one by @alex li , but for Pydantic 2.X and with some improvements!

Test script (test.py)

from typing import Any

from pydantic import BaseModel, Field, FieldValidationInfo, field_validator
from pydantic_core import PydanticUndefined


class MyClass(BaseModel):
    my_field: int = Field(
        default=20,
        title="My field.",
        description="My field.",
        examples=["20"],
    )

    @field_validator("*", mode="before")
    @classmethod
    def use_default_value(cls, value: Any, info: FieldValidationInfo) -> Any:

        # NOTE: All fields that are optional for values, will assume the value in
        # "default" (if defined in "Field") if "None" is informed as "value". That
        # is, "None" is never assumed if passed as a "value".
        if (
            cls.model_fields[info.field_name].get_default() is not PydanticUndefined
            and not cls.model_fields[info.field_name].is_required()
            and value is None
        ):
            return cls.model_fields[info.field_name].get_default()
        else:
            return value


print(MyClass(my_field=30))
print(MyClass(my_field=None))
print(MyClass())

On BASH terminal

(my-python-script) [user@my-pc my-python-script]$ python test.py
my_field=30
my_field=20
my_field=20