Cannot control json serialization with custom response_class

[tangi75]

class CustomJSONResponse(JSONResponse):
    media_type = "application/json"

    def render(self, content: typing.Any) -> bytes:
        return dumps(content)

With dumps being a custom function, managing datetime values specifically.

@router.post("/requests")
async def insert_user_request(request: Request):
   return CustomJSONResponse(content={"timestamp": datetime.now()}, status_code=HTTP_201_CREATED)

Will work as expected but

@router.post("/requests", response_class=CustomJSONResponse, status_code=HTTP_201_CREATED)
async def insert_user_request(request: Request):
    return {"timestamp": datetime.now()}

Will fail to use the custom dump function.

The cause is in https://github.com/tiangolo/fastapi/blob/master/fastapi/routing.py#L190 : serialize_response (which calls jsonable_encoder) is called before the response_class instantiation (https://github.com/tiangolo/fastapi/blob/master/fastapi/routing.py#L201) so datetime values are converted to str prematurely.

[TTRh]

datetime encoder is coming from pydantic : https://github.com/samuelcolvin/pydantic/blob/master/pydantic/json.py#L20 i guess it's still possible to alter this one if we need custom encoder for datetime.

[tangi75]

@TTRh : the explicit return of an CustomJSONResponse instance works fine without having to tweak pydantic. My point is that I wouldn't have expected a different behavior between the two syntaxes.

[kshilov]

Have the same issue. Did you solve it?

[tangi75]

Have the same issue. Did you solve it?

Only a PR would really solve it, provided it's considered as an issue, hence my "question" here.
Two possible workarounds:

1. Explicit instantiation as illustrated above
2. Tweak pydantic as suggested by @TTRh, e.g. pydantic.json.ENCODERS_BY_TYPE[datetime] = lambda dt: dt.replace(tzinfo=pytz.utc).isoformat()

[ycd]

@kshilov also you can create a workaround with default=str and encode()

class CustomJSONResponse(JSONResponse):
    media_type = "application/json"

    def render(self, content: typing.Any) -> bytes:
        return dumps(content, default=str).encode()

This will work however, I agree with @tangi75 it is a serious bug and should be handled by a PR.

[atellier]

I have the same issue where I want Enums to return the name and not the value of the object. I ended up creating my own JSONResponse and had to wrap all my return in to a JSONResponse(...). It would have been nice to just use the response_class option, but because serialize_response is called before my custom JSONResponse, it does not work.

Looks like on the pydantic side there is also no real easy way to use our own JSON serializer - which would be very useful since people may want to do serialization differently (for instance when returning nan from pandas / numpy).

Any chance of that making to a PR or it that too much of a change that it would break things?

Thanks

[nguyent]

Looks like on the pydantic side there is also no real easy way to use our own JSON serializer - which would be very useful since people may want to do serialization differently (for instance when returning nan from pandas / numpy).

+1

I'm currently using FastAPI for an API migration and want to use a custom json encoder for parity reasons.
I discovered this after diffing responses from both APIs.

A small example of what I'm seeing (this timestamp is from a pandas dataframe):

legacy timestamp: "2022-01-06 00:00:00+00:00"
fastapi timestamp: "2022-01-06T00:00:00+00:00"

Current FastAPI code

(shortened version of the current code in get_request_handler)

raw_response = await run_endpoint_function(...)
response_data = await serialize_response(response_content=raw_response, ...)
response = actual_response_class(response_data, **response_args)

serialize_response calls the default FastAPI jsonable_encoder meaning response_data has been encoded before the actual_response_class is invoked.

It seems like the recommendation in this thread is to explicitly return a custom Response inside each route -- that does work, but it would be nice if we could just set a default_response_class when initializing FastAPI and call it a day.

Would it be possible to either:

• pass raw_response as a kwarg to actual_response_class?
• pass along a custom json encoder that would be called inside serialize_response?

[ntakouris]

@nguyent +1 on this, I am using mashumaro.