How to Apply Custom Function to Return DTO Fields

[colinbrust]

I have a model for some location data that looks like this:

from msgspec import Struct
from litestar.dto import MsgspecDTO, DTOConfig

class Location(Struct):
    name: str
    latitude: float
    longitude: float

In my return_dto, I would like to round the latitude and longitude values. Is there a way to apply a function to the return values in your DTOConfig? Something along the lines of:

class WriteDTO(MsgspecDTO[Location]):
    # Effectively what I would like to do.
    config = DTOConfig(change={'latitude': lambda x: round(x, 2)})

I know that I could include a latitude_rounded and longitude_rounded field and then exclude the original lat/lon fields, but was just wondering if something like this is possible.

Thanks!

[peterschutt]

There's no way for DTOs to do this, as yet.

You can do it without DTOs, if you have an appetite for using a custom float type for the coordinates, e.g.,:

from __future__ import annotations

import msgspec

from litestar import Litestar, post


class RoundedFloat(float): ...


class Location(msgspec.Struct):
    name: str
    latitude: RoundedFloat
    longitude: RoundedFloat


@post("/")
async def index(data: Location) -> Location:
    return data


app = Litestar(
    route_handlers=[index],
    type_decoders=[(lambda x: issubclass(x, RoundedFloat), lambda typ, val: typ(val))],
    type_encoders={RoundedFloat: lambda val: round(val, 2)},
    debug=True,
)

If this was to be something we support with DTOs, there is two points when the DTOs have their hands on the data:

1. after parsing raw bytes into an instance of the transfer model, we then move that data on to an instance of the domain model, or into an instance of DTOData.
2. after a handler returns a domain model, we move the data onto an instance of the transfer model, before it is encoded and sent to the client.

At either of those points, we'd be able to apply a transformer function to the data for each field.

[colinbrust]

Thank you for the quick response! I ended up implementing the workaround below, but I'll also take a take a look at your method.

I'm migrating over to Litestar from FastAPI so am still getting oriented to things. Does this sort of feature align with the intended use case of DTOs? Or would it be better practice to handle these sorts of operations within the application logic like in your example?

from msgspec import Struct
from litestar.dto import MsgspecDTO, DTOConfig

class Location(Struct):
    name: str
    latitude: float
    longitude: float
    latitude_rounded: float | None = None
    longitude_rounded: float | None = None

    def __post_init__(self):
        self.latitude_rounded = round(self.latitude, 2)
        self.longitude_rounded = round(self.longitude, 2)

class WriteDTO(MsgspecDTO[Location]):
    config = DTOConfig(
        exclude={"latitude", "longitude"},
        rename_fields={
            "latitude_rounded": "latitude",
            "longitude_rounded": "longitude",
        },
    )

[peterschutt]

Your solution looks good! I assume the openapi docs show "latitude" and "longitude" as union with None?

Does this sort of feature align with the intended use case of DTOs?

On the surface, yeah. DTOs are concerned with transferring data from your domain models to the user, and this seems to fit that philosophy.

One thing concerns me. Lets say we introduce a callable between the data that we transfer from the domain model returned from a handler, and the transfer model that we encode in the response, conceptually like this:

def transformer(val: float) -> float:
    return round(val, 2)

# pseudo code

domain_instance = await handler()  # the model instance returned from the handler
plucked_value = domain_instance.val  # a value we take from the instance to put into the transfer model instance
transformed_value = transformer(val)  # passed through transformer
transfer_instance = TransferModel(val=val)  # construct transfer instance
encoded_content = msgspec.json.encode(transfer_instance)  # encode response

And, the transformer function is configured to the DTO via config, something like DTOConfig(transform={"val": transformer}). Then, there is no way for us to know that the value returned from the transformer function is consistent with the type defined on the domain/transfer model for that attribute.