Mutable default behavior

[mattkram]

Hi All!

I've searched the docs, but I'm hoping someone may be able to confirm the behavior for me. Once confirmed, I am happy to provide a PR with a small clarification in the (amazing) docs.

In many frameworks (e.g. dataclasses), there is a default_factory argument for fields, which is used for mutable types. This doesn't appear to be available in FastAPI. Are there any issues with mutable defaults in FastAPI?

For example, we may have a body like this:

async def my_route(body: SomeModel = fastapi.Body(default=SomeModel()):
    ...

In this case, are there any issues or risks related to the default being mutable, or is this a non-issue in the FastAPI implementation?

Thank you in advance for any help you can give!

[odiseo0]

Body doesn't have a default_factory parameter but you could use classes as dependencies. Docs

[zoliknemet]

There is strange behavior or I do not understand how things work
I tried this:

import random

import uvicorn as uvicorn

from fastapi import FastAPI, Body
from typing import Optional
from pydantic import BaseModel

app = FastAPI()

class SomeModel(BaseModel):
    id: Optional[int]
    name: Optional[str]


@app.post("/model")
async def my_route(body: SomeModel = Body(default=SomeModel())):
    print(f"My SomeModel ID is {id(body)}")
    if random.randint(0, 1):
        print("Changing it's value")
        body.id = 99
    return body


if __name__ == "__main__":
    uvicorn.run(app)

result:

My SomeModel ID is 139627970259424
Changing it's value
99
My SomeModel ID is 139627970261008
None
My SomeModel ID is 139627970258080
Changing it's value
99
My SomeModel ID is 139627970259472
Changing it's value
99
My SomeModel ID is 139627970258272
None
My SomeModel ID is 139627970258224
None
My SomeModel ID is 139627970260672
None
My SomeModel ID is 139627970259616
Changing it's value
99
My SomeModel ID is 139627970261152
Changing it's value
99
My SomeModel ID is 139627970259760
Changing it's value
99
My SomeModel ID is 139627970261296
None

every call we get NEW instance of SomeModel

Python does not work like that when used in pure method
Example:

def pure_method(body=SomeModel()):
    print(f"My SomeModel ID is {id(body)}")
    if random.randint(0, 1):
        print("Changing it's value")
        body.id = 99
    return body

if __name__ == "__main__":
    for i in range(10):
        print(pure_method())

result:

My SomeModel ID is 139895171656352
Changing it's value
id=99 name=None
My SomeModel ID is 139895171656352
id=99 name=None
My SomeModel ID is 139895171656352
Changing it's value
id=99 name=None
My SomeModel ID is 139895171656352
id=99 name=None
My SomeModel ID is 139895171656352
Changing it's value
id=99 name=None
My SomeModel ID is 139895171656352
id=99 name=None
My SomeModel ID is 139895171656352
Changing it's value
id=99 name=None
My SomeModel ID is 139895171656352
id=99 name=None
My SomeModel ID is 139895171656352
Changing it's value
id=99 name=None
My SomeModel ID is 139895171656352
Changing it's value
id=99 name=None

Its always the same object!
The question is what happens on Fastapi/Pydantic stack that does not work with same instance of SomeModel but instead on each call creates new instance?

[mattkram]

Thank you for writing this example. This is the same behavior as in Python method defaults, and was the root of my question.

def f(x = []):
    print(id(x))
    x.append(1)
    print(x)

for i in range(10):
    f()

That will always print the same id because the default value is stored on the function object itself, and the list x will grow every time you call the function:

140203437137728
[1]
140203437137728
[1, 1]
140203437137728
[1, 1, 1]
140203437137728
[1, 1, 1, 1]
140203437137728
[1, 1, 1, 1, 1]
140203437137728
[1, 1, 1, 1, 1, 1]
140203437137728
[1, 1, 1, 1, 1, 1, 1]
140203437137728
[1, 1, 1, 1, 1, 1, 1, 1]
140203437137728
[1, 1, 1, 1, 1, 1, 1, 1, 1]
140203437137728
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

I need to review the use of the callable that was posted earlier by @odiseo0 . I am familiar with using Depends with callables, but I need to understand how that fits with default values.

[mattkram]

Wow, I totally mis-read your original answer!

Your example has confirmed to me that FastAPI/pydantic do something different than default python method arguments. Thus, the mutable default problem is not an issue.

[mattkram]

Just to follow up again, I modified the example and confirmed that the body.id does not carry over between calls.

@app.post("/model")
async def my_route(body: SomeModel = Body(default=SomeModel())):
    print(f"My SomeModel ID is {id(body)}")
    print(f"Before setting the id: {body.id=}")
    body.id = random.randint(0, 10000)
    print(f"After setting the id: {body.id=}")
    return body

[pouriazmn]

It seems to be fixed, at least in version 0.111.0. I just checked, and there is a default_factory argument for all request parameter classes (see ref).

Why does the id of the mutable default value change?
Based on pydantic documentation, if the default value is "non-hashable", a deepcopy of the default will be assigned. (see fields with non-hashable default values from the pydantic reference).

However, it is not the case! The default value is deep copied using the pydantic._internals._utils.smart_deepcopy method.

It is called in FieldInfo.get_default, which is the parent of fastapi.params.Param.

I have just started to review the code and docs of these amazing projects and might be wrong. However, I had the same question and I am guessing this is a convincing one.