Reconciling Dataclasses And Properties In Python - Florimond Manca

[utterances-bot]

Reconciling Dataclasses And Properties In Python - Florimond Manca

I love Python dataclasses, but combining them with properties is not obvious. This is a problem solving report — and a practical introduction to dataclasses!

https://florimond.dev/en/posts/2018/10/reconciling-dataclasses-and-properties-in-python/

[sujittiwari]

Appreciate your effort to bring this detailed analysis, It really help us to take deep dive.
But still, have a question about @wheels.setter if we provide a setter to a protected/private variable then didn't we lose the intent of having one(protected/private )?

[ruslaniv]

Great article!
Could you maybe extend this article and write about setting a default value to an attribute using dataclasses and properties (because of this: python/cpython#94067)? Right now I'm setting a default value in a parent class and then subclassing it but maybe there is a more elegant solution?

[florimondmanca]

@ruslaniv It seems you can set _wheels: int = field(..., default=...).

from dataclasses import dataclass, field

@dataclass
class Vehicle:
    wheels: int
    _wheels: int = field(init=False, repr=False, default=4)

    @property
    def wheels(self) -> int:
        print("getting wheels")
        return self._wheels

    @wheels.setter
    def wheels(self, wheels: int) -> None:
        print("setting wheels to", wheels)
        self._wheels = wheels

But this wouldn't work: the wheels setter receives the wheels property on init, instead of 4.

>>> Vehicle()
setting wheels to <property object at 0x1045ff100>
getting wheels
Vehicle(wheels=<property object at 0x1045ff100>)

After some digging into the source code of the dataclasses module, this is because of these lines:

# dataclasses.py, L730:732
    # If the default value isn't derived from Field, then it's only a
    # normal default value.  Convert it to a Field().
    default = getattr(cls, a_name, MISSING)

When processing the class, getattr(Vehicle, "wheels", MISSING) returns the wheels property. This value is later used as the default and passed to the setter via self.wheels = _wheels_dflt in the generated __init__.

We can't set a default using wheels: int = 4, because the later definition of the property would override it.

One solution that would work is ignoring that initial property value...

    @wheels.setter
    def wheels(self, wheels: int) -> None:
        if isinstance(wheels, property):
            return
        print("setting wheels to", wheels)
        self._wheels = wheels

Output:

>>> Vehicle()
getting wheels
Vehicle(wheels=4)

This could be moved to a minimal dataclass_property implementation, like so...

class dataclass_property(property):
    def __set__(self, obj, value):
        if isinstance(value, property):
            # dataclasses tries to set a default and uses the
            # getattr(cls, name). But the real default will come
            # from: `_attr = field(..., default=...)`.
            return
        super().__set__(obj, value)

Usage would be to replace @property with @dataclass_property.

I won't comment on the level of hackiness, but any usage of the approach described in this blog post was already in the "NO WARRANTY PROVIDED" zone. :-)

[hasii2011]

Thanks for this walk through and the short and sweet "recipe" at the end

[DougLeonard]

Nice article.
I'm fond of this way personally:

@dataclass
class Vehicle_6:

    wheels: int  = 2  # only need one variable.

    #Setter for all attributes:
    def __setattr__(self, name, value):
        if (name == "wheels") and (value <1):  # sanitize wheels here:
            value=1  
        #if (name == something_else):
        #    ...
        super(self.__class__, self).__setattr__(name, value)

No backing field needed at all. You can still have private fields, but for derived things.

For what it's worth, I also I found the following seems to get around calling the setter in my limited testing, but I don't remember details now:

    def __post_init__(self, wheels):   # override the init:
        if not isinstance(wheels, property):  # wheels attribute and property clash a bit.
            self._wheels = wheels

as may a direct dictionary access, but it's still not nice.

[DougLeonard]

I should probably say that without a backing field, you will normally* be using the setter for internal access too. So there's that. It depends. Of course you can use a backing field with setattr too. And you can simplify setter logic of the type, if self.a || self.b || self.c then self.d = True. To me setattr just gets it all done.

*unless you go through self.dict["wheels"], but at that point it's silly.

[vbttchr]

For your final solution:

from dataclasses import dataclass, field

@dataclass
class Vehicle:
    wheels: int
    _wheels: int = field(init=False, repr=False)

    @property
    def wheels(self) -> int:
        return self._wheels

    @wheels.setter
    def wheels(self, wheels: int):
        self._wheels = wheels

pylance/mypy type checking complains with

Declaration "wheels" is obscured by a declaration of the same name (PylancereportRedeclaration)

I didnt find any clean and runable conciliation between property and dataclass, where property has the same name when initializing an instance and setting/getting that property.