How to forward annotation of __init__ of a dataclass?

[FindDefinition]

I have a complex dataclass:

@dataclasses.dataclass
class ComponentBaseProps(BasicProps):
    flex: Union[int, str, Undefined] = undefined
    align_self: Union[str, Undefined] = undefined
    flex_grow: Union[str, Undefined] = undefined
    flex_shrink: Union[str, Undefined] = undefined
    flex_basis: Union[str, Undefined] = undefined
    ...

now I want to use annotation of that dataclass in a function:

class Component(Generic[T]):
    def __init__(self,
                 prop_cls: Type[T]) -> None:
        self.__props = prop_cls()
        self.__prop_cls = prop_cls

    def prop(self, ANNOTATION_OF_ComponentBaseProps_INIT):
         ...

The only solution I found is treat ComponentBaseProps as a callable:

def init_anno_fwd(this: Callable[P, T2]) -> Callable[[Callable], Callable[P, T2]]:
    def decorator(real_function: Callable) -> Callable[P, T2]:
        def new_function(*args: P.args, **kwargs: P.kwargs) -> T2:
            return real_function(*args, **kwargs)
        return new_function
    return decorator

class Component(Generic[T]):
    def __init__(self,
                 prop_cls: Type[T]) -> None:
        self.__props = prop_cls()
        self.__prop_cls = prop_cls

    @property
    def prop(self) -> Type[T]:
        @init_anno_fwd(self.__prop_cls)
        def wrapper(**kwargs):
            for k, v in kwargs.items():
                setattr(self.__props, k, v)
            return self
        return wrapper # type: ignore

This works in pylance.

Questions:

1. Is it valid to treat a type as a callable?
2. currently I need to ignore return annotation error, is there better way to do this?

[erictraut]

Yes, it is valid to treat a type as a callable. The callable signature is derived from the constructor of the class (either __new__ or __init__ or a combination of both).

I don't see a better way of doing this. The challenge is that your code assumes that the constructor accepts a bunch of parameters but can also be called with no arguments (because all of the parameters have defaults). There's no way to express that constraint in the type system, so the type checker doesn't know that you're making this assumption.

[FindDefinition]

I replace Type[T] with Callable[P, T], now code looks more reasonable and don't need "type: ignore" anymore, thanks!

class Component(Generic[T]):
    def __init__(self,
                 prop_cls: Callable[P, T],
                 *args: P.args,
                 **kwargs: P.kwargs) -> None:
        self.__props = prop_cls(*args, **kwargs)
        self.__prop_cls = prop_cls

    @property
    def prop(self) -> Callable[P, T]:
        def wrapper(*args: P.args, **kwargs: P.kwargs):
            for k, v in kwargs.items():
                setattr(self.__props, k, v)
            return self.__props
        return wrapper 

[FindDefinition]

can't we use type metadatas derived from __init__ in member functions? I can't find any valid solution except Type[T]

from typing import Generic, TypeVar, Callable , Type, Any, Optional
from typing_extensions import ParamSpec
import dataclasses
P = ParamSpec('P')
T = TypeVar('T')

T2 = TypeVar('T2')
T3 = TypeVar('T3')

@dataclasses.dataclass
class Props:
    a: int = 3
    b: int = 5
    c: int = 4


def init_anno_fwd(this: Callable[P, Any], val: Optional[T3] = None) -> Callable[[Callable], Callable[P, T3]]:
    def decorator(real_function: Callable) -> Callable[P, T3]:
        def new_function(*args: P.args, **kwargs: P.kwargs) -> T3:
            return real_function(*args, **kwargs)
        return new_function
    return decorator

class Component(Generic[T]):
    def __init__(self,
                 prop_cls: Callable[P, T],
                 prop_cls2: Type[T],
                 *args: P.args,
                 **kwargs: P.kwargs) -> None:
        self.__props = prop_cls(*args, **kwargs)
        self.__prop_cls = prop_cls
        self.prop_cls2 = prop_cls2


    @property
    def prop_pylance_works(self) -> Type[T]:
        def wrapper(*args: P.args, **kwargs: P.kwargs):
            for k, v in kwargs.items():
                setattr(self.__props, k, v)
            return self.__props
        return wrapper 


    @property
    def prop_pylance_dont_work(self) -> Callable[P, T]:
        def wrapper(*args: P.args, **kwargs: P.kwargs):
            for k, v in kwargs.items():
                setattr(self.__props, k, v)
            return self.__props
        return wrapper 

    @property
    def prop_pylance_dont_work_too(self):
        @init_anno_fwd(self.prop_cls2, self.__props)
        def wrapper(**kwargs):
            for k, v in kwargs.items():
                setattr(self.__props, k, v)
            return self.__props
        return wrapper 

    @property
    def prop_pylance_works_too_but_trivial(self):
        @init_anno_fwd(Props, self.__props)
        def wrapper(**kwargs):
            for k, v in kwargs.items():
                setattr(self.__props, k, v)
            return self.__props
        return wrapper 



a = Component(Props, Props)

a.prop_pylance_works
a.prop_pylance_dont_work
a.prop_pylance_dont_work_too
a.prop_pylance_works_too_but_trivial