Best practice annotating dataclasses to solve the __init__ problem

[randolf-scholz]

What is the best way to avoid this common problem when combining dataclasses with type hints?

We have an attribute that should be of some type, for instance pathlib.Path. However, for the init function, it would be desirable to allow str as well, and cast it to Path in __post_init__. Type hinting Path | str is problematic if internal methods of the class rely on Path-methods.

from dataclasses import dataclass
from pathlib import Path

@dataclass
class Foo:
    path: Path  # we would really like the __init__ to accept str as well
    
    def __post_init__(self) -> None:
        self.path = Path(self.path).absolute()

# then, in some test code / user code
Foo("tests/")  # ✘ incompatible type "str"

Are there any better resolutions than plastering type: ignore comments or ditching dataclasses altogether?

[sobolevn]

Won't something like this work for you?

@dataclass 
class Foo:
   path: Path | str # | whatever
   @property
   def real_path(self) -> Path:
       return Path(self.path).absolute()

?

[randolf-scholz]

I guess one can do that but it is annoying that the class then essentially has duplicate attributes that also show up in documentation. The standard __repr__, __eq__ and all of the other useful things about dataclasses also would end up using path instead of real_path.

[erictraut]

You could use an InitVar, like this:

@dataclass
class Foo:
    _path: InitVar[Path | str]

    def __post_init__(self, _path: Path | str) -> None:
        self.path = Path(_path).absolute()

[erictraut]

Or define your own __init__ rather than relying on the synthesized method:

@dataclass
class Foo:
    path: Path

    def __init__(self, path: Path | str) -> None:
        self.path = Path(path).absolute()