Typing a generic function that takes a constructor with arbitrary parameters

[gh-andre]

I have a function that takes a generic type and constructs an instance of this type with arbitrary arguments specific to that type. Typing those *args and **kwargs as Any isn't very helpful, but I cannot seem to find the official way to pass constructor argument types into such function because ParamSpec requires a Callable.

I was able to accomplish what I'm looking for via this awkward syntax and wonder if anybody can suggest how to avoid using Callable for this.

from typing import TypeVar, ParamSpec, Callable, Concatenate

class X:
    def __init__(self, i: int, s: str) -> None:
        pass

class Y:
    def __init__(self, f: float) -> None:
        pass

T = TypeVar("T")
P = ParamSpec("P")
        
def fn(ctor: type[T],
        _: Callable[Concatenate[T, P], None],
        *args: P.args, **kwargs: P.kwargs) -> T:
        
    return ctor.__new__(ctor, *args, **kwargs)
    
x: X = fn(X, X.__init__, 123, "XYZ")
y: Y = fn(Y, Y.__init__, 12.34)

Thanks!

[erictraut]

All class objects are valid Callable's. The constructor (both the __new__ and __init__ methods) are converted into a callable according to these rules.

With this in mind, you can simplify your code to the following:

def fn[**P, T](_type: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
    return _type(*args, **kwargs)

x: X = fn(X, 123, "XYZ")
y: Y = fn(Y, 12.34)

[gh-andre]

I spent a bunch of time today on Google trying to find official docs on relationship between type[C] and Callable and regardless of how I crafted the query, the linked page evaded me. This is great. Thanks!