How can I differentiate explicit nulls when creating the request model?

[gs11]

For updating data in a system, a PATCH operation accepts partial payloads to only update the explicitly included properties.
As it's desirable to clear some integer values, I'd need to distinguish explicit null properties from absent properties.

How can I configure the model so that the parsed instance represents both absent and explicit nulls?
I've (unsuccessfully) tried various combos:
my_field: Optional[int] = Unset() - yields Unset type for both implicit/explicit null
my_field: Union[int, None] = Unset() - also yields Unset type for both implicit/explicit null

[frankie567]

The key is to use the exclude_unset argument of the .dict method of a Pydantic model:

• https://pydantic-docs.helpmanual.io/usage/exporting_models/#modeldict
• https://fastapi.tiangolo.com/tutorial/body-updates/?h=patch#using-pydantics-exclude_unset-parameter

Here is a simple example:

from typing import Optional
from pydantic import BaseModel

class Model(BaseModel):
    my_field: Optional[int] = None

m1 = Model()
assert m1.dict(exclude_unset=True) == {}

m2 = Model(my_field=None)
assert m2.dict(exclude_unset=True) == {"my_field": None}

[gs11]

Thanks but not sure this works as the parsed model will have all implicitly/explicitly null set properties as None.

async def update_object_by_id(object_id: int, request: models.api.UpdateRequest):

[frankie567]

If you work with the object instance, yes, all the values will be None, but transforming it to a dictionary with exclude_unset will only give you the fields that were explicitly set as None.

This approach works well in combination of copy, where you take your model from the database and update it with such dictionary; as you can see in the documentation:

@app.patch("/items/{item_id}", response_model=Item)
async def update_item(item_id: str, item: Item):
    stored_item_data = items[item_id]
    stored_item_model = Item(**stored_item_data)
   
    # The interesting part
    update_data = item.dict(exclude_unset=True)
    updated_item = stored_item_model.copy(update=update_data)

    items[item_id] = jsonable_encoder(updated_item)
    return updated_item

[gs11]

Thanks, right now all logic is built upon the models which (in my case) is a lot more convenient to work with.
I eventually opted for adding a class validator that yields an custom explicit null type for every explicit null.

@validator('*')
def parse_explicit_nulls(cls, value):
    if value is None:
        return ExplicitNull()
    else:
        return value

Implicit nulls (unset) never hit the validator and will thus be just None in the parsed model instance.