Is there a Pydantic convention for a Model attribute that will default to a function of another attribute?

I want to define a Pydantic BaseModel with the following properties:

• Two int attributes a and b.
• a is a required attribute
• b is optional, and will default to a+1 if not set.

Is there a way to achieve this? This is what I've tried.

from typing import Optional

from pydantic import BaseModel, validator


class A(BaseModel):
    a: int
    b: Optional[int] = None  # want to default to a+1 if not set
    
    @validator('b', always=True)
    def default_b_value(cls, b, values):
        if b is None and 'a' in values:
            return values['a']+1
        return b

My problem with this is it doesn't match the guarantees of A. For any A that's actually constructed, b will never be None so its type should be int, not Optional[int].

I would not presume to know about conventions for this, but to achieve the behavior you want, you have a few options.

One way is to define b as being of the type int and setting a default_factory to return a sentinel value, then identity-check for that value in the validator, similar to what you did with None. I suppose the cleanest way (in the type safety sense) would be to subclass int just for that purpose to have an object that is actually distinct while still being of the correct type.

from typing import Any, cast

from pydantic import BaseModel, Field, validator


class _SentinelInt(int):
    pass


_sentinel_int = _SentinelInt()


class Foo(BaseModel):
    a: int
    b: int = Field(default_factory=lambda: _sentinel_int)

    @validator("b", always=True)
    def default_b_value(cls, v: int, values: dict[str, Any]) -> int:
        if v is _sentinel_int:
            return cast(int, values["a"] + 1)
        return v

Side note: You can be sure that the a value is present in the values dictionary because validation occurs in the order that fields are defined.

Demo:

foo1 = Foo(a=42)
foo2 = Foo(a=-1, b=69)
print(foo1.json(indent=4))
print(foo2.json(indent=4))

Output:

{
    "a": 42,
    "b": 43
}

{
    "a": -1,
    "b": 69
}

An arguably less clean way would be to simply stick with None as the default but still type b as int and simply set a specific type: ignore directive for the default assignment:

from typing import Any, cast

from pydantic import BaseModel, validator


class Foo(BaseModel):
    a: int
    b: int = None  # type: ignore[assignment]

    @validator("b", always=True)
    def default_b_value(cls, v: int, values: dict[str, Any]) -> int:
        if v is None:
            return cast(int, values["a"] + 1)
        return v

From the perspective of the type checker and for all intents and purposes at runtime the value of the b field of any instance will always be an int, so I would say this approach is well justified. Even though it may not be strictly type safe, the intent is still crystal clear.