Python frozen dataclass with an optional parameter but non-optional field type

Question

I have a dataclass such as this one:

@dataclasses.dataclass(frozen=True)
class MyClass:
    my_field: str
    other_field: str

and I have a complicated function for computing a default value for my_field that depends on other_field:

def get_default_value_for_my_field(other_field: str) -> str:
    ...  # lots of code

Is there a way to:

1. Call get_default_value_for_my_field(other_field) and initialize my_field from its result if no value for my_field is passed at initialization, otherwise initialize my_field from the passed value;
2. Keep MyClass frozen;
3. Convince pytype that MyClass.my_field has type str rather than str | None;
4. Convince pytype that MyClass.__init__() has a parameter my_field: str | None = None

using dataclasses, or am I better off switching to a plain class?

Answer 1

I don't think that all those conditions are possible using daclasses. I used to have the same problem and found a package that can actually solve all the above very easily. The package is call attrs, and if you use dataclasses you can see it does the same things but add some very cool features, without disturbing the class or similar as pydantic does. It work the same as a dataclass and you probably will need to change very little of your code to move from dataclass to attrs, but is true it add a new dependency.

from attrs import define

def get_default_value_for_my_field(other_field: str) -> str:
    ...  # lots of code


@define(frozen=True)
class MyClass:
    other_field: str
    my_field: str 

    def __init__(self, other_field: str, my_field: str|None):
        if not my_field:
            my_field = get_default_value_for_my_field(other_field)
        self.__attrs_init__(other_field=other_field, my_field=my_field)

Answer 2

Add a "named constructor" classmethod to your dataclass:

@dataclasses.dataclass(frozen=True)
class MyClass:
    my_field: str
    other_field: str

    @classmethod
    def from_other(cls, other_field: str) -> MyClass:
        my_field = default_for_my_field(other_field)
        return cls(my_field, other_field)

You can then create MyClass instances as either

MyClass("my field", "other field")

or

MyClass.from_other("other field")

With this approach, MyClass stays a "dumb" plain-old-data class. Special default value logic only kicks in at the user's request (by using the "named constructor").