FastAPI ignores the "ser_json_inf_nan" config of pydantic (other config-options work)

[exhuma]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from typing import Any

from fastapi import FastAPI, Response
from pydantic import BaseModel, ConfigDict


class InfTest(BaseModel):
    model_config = ConfigDict(ser_json_inf_nan="strings")
    value: float


class NestedList(BaseModel):
    model_config = ConfigDict(ser_json_inf_nan="strings")
    values: list[InfTest]


app = FastAPI()


@app.get("/")
@app.get("/simple-value")
def simple_value() -> InfTest:
    """
    This demonstrates the simplest form of code that is *expected* to run.

    In FastAPI 0.111.0 with pydantic 2.8.2 and starlette 0.372 calling this will
    result in a 500 error.
    """
    return InfTest(value=float("inf"))


@app.get("/simple-list")
def simple_list() -> list[InfTest]:
    """
    This demonstrates a simple "list" that is expected to work.

    It fails with the same error as the "/simple-value" route
    """
    return [InfTest(value=float("inf"))]


@app.get("/nested-list")
def nested_list():
    """
    This demonstrates a shoe-in for a more complex object that is also expected
    to work.

    It also fails with the same error as the "/simple-value" route
    """
    data = NestedList(
        values=[
            InfTest(value=float("inf")),
            InfTest(value=float("-inf")),
            InfTest(value=float("nan")),
        ]
    )
    return data


@app.get("/working-simple-value")
def working_simple_value() -> Response:
    """
    This demonstrates a working example. It is achieved by manually encoding
    the objects.

    This works fine for simple objects, but is not feasible when dealing with
    more complex objects used in our internal code-base that uses a generic
    implementation for pagination.
    """
    output = InfTest(value=float("inf"))
    return Response(output.model_dump_json(), media_type="application/json")


@app.get("/broken-simple-list")
def broken_simple_list() -> list[Any]:
    """
    This demonstrates a broken implementation that works partially. The
    list-items are valid JSON and honour the ``ser_json_inf_nan`` setting, but
    end up as "strings" which are then "doubly-encoded" as JSON.
    """
    data = [InfTest(value=float("inf"))]
    items = [item.model_dump_json() for item in data]
    return items

Description

JSON does not have native support for "infinity" values. Pydantic provides a simple solution to this by setting ser_json_inf_nan to strings. Manually running my_object.model_dump_json() on such an instance works as expected.

However, when running it through FastAPI the application crashes with the attached traceback:
traceback.txt

The code was executed in a virtual environment with the packages listed in requirements.txt

The demo-application provides several endpoints, each demonstrating the same error from different perspecives. It also demonstates a "workaround". That workaround is limited and cannot be applied in our internal application where we noticed this issue.

Operating System

Linux

Operating System Details

No response

FastAPI Version

0.111.0

Pydantic Version

2.8.2

Python Version

3.12.0

Additional Context

No response

[exhuma]

While not an answer, I have found a workaround for now. It is really inefficient because I need to go through an extra-step of JSON encoding/decoding, but it helps me to move forward with my work.

The key issue I have is that the object that contain the "infinity" values are nested inside a list of "items" which is part of a list-object wrapper returned by the API. The details are irrelevant and I'll simplify the example here, but the core issue remains that a nested list contains objects with infinity values like this:

{"items": [{"myvalue": "Infinity"}]}

The workaround looks like this (based on the code above):

from json import loads
from pydantic import TypeAdapter

# ...

@app.get("/nested-list")
def nested_list():
    """
    ...
    """
    data = NestedList(
        values=[
            InfTest(value=float("inf")),
            InfTest(value=float("-inf")),
            InfTest(value=float("nan")),
        ]
    )
    # Use a type-adapter to encode the list of objects manually.
    # This will replace the `inf` values with their string-representations. We can then
    # put that back into the "nested list" which will get rid of the crash, at the cost of
    # performance due to the extra json "de-/encode" step.
    adapter = TypeAdapter(list[InfTest])
    new_values_json = adapter.dump_json(data.values)
    new_values = loads(new_values_json)
    new_data = data.model_copy(update={"values": new_values})
    return new_data

[gustavosett]

You need a custom JSON encoder that can handle infinity and NaN values according to your Pydantic model's configuration.

1. create something like this:

   from fastapi.responses import JSONResponse
   from fastapi.encoders import jsonable_encoder
   from json import JSONEncoder
   
   class CustomJSONEncoder(JSONEncoder):
       def default(self, obj):
           if isinstance(obj, float):
               if obj == float('inf'):
                   return "Infinity"
               elif obj == float('-inf'):
                   return "-Infinity"
               elif obj != obj:  # NaN check
                   return "NaN"
           return JSONEncoder.default(self, obj)
   
   def custom_json_response(content):
       return JSONResponse(content=jsonable_encoder(content, custom_encoder=CustomJSONEncoder))

2. adjust your endpoints to use this custom JSON response.

   @app.get("/nested-list", response_class=JSONResponse)
   def nested_list():
       data = NestedList(
           values=[
               InfTest(value=float("inf")),
               InfTest(value=float("-inf")),
               InfTest(value=float("nan")),
           ]
       )
       return custom_json_response(data)