Type interference: `ProtocolOf`?

I'm looking the way to interfere existing types explicitly, like typeof / keyof in Typescript

I have 2 use cases:

• existing function definition -> Callable[...]
• dataclass __init__ signature / protocol

I think it should look like:

from typing import ProtocolOf

def foo(a: int, b: float) -> float:
    return a * b

FooProtocol = ProtocolOf[foo]

Should be equal to:

class FooProtocol(Protocol):
    def __call__(a: int, b: float) -> float: ...

Or dataclasses:

from dataclasses import dataclass
from typing import ProtocolOf

@dataclass()
class Foo:
    a: int
    b: float

Here I'm not sure which way is better

# way 1:
FooProtocol = ProtocolOf[Foo]

Should be equal to:

class FooProtocol(Protocol):
    def __call__(a: int, b: float) -> Foo: ...

# way 2:
FooInitProtocol = ProtocolOf["Foo.__init__"]

Should be equal to:

class FooInitProtocol(Protocol):
    def __call__(a: int, b: float) -> None: ...

Callable / Protocol to ParamSpec / Returning to use in typing

I see typing.get_args but it doesn't looks suitable for typing. Also

from collections.abc import Callable
from typing import get_args

FooSignature = Callable[[int, float], float]
get_args(FooSignature)  # == [[int, float], float]

Instead of that it should be way to define FooParamSpec / FooReturning

Bonus

there are no way to convert TypedDict to ParamSpec.kwargs
UPD: is't bound to typing.Unpack

Beginnen Sie mit der Durchsicht der Beispiele des Issues und der darin referenzierten APIs typing.get_args, Callable, Protocol, ParamSpec, TypedDict, Unpack und dataclasses. Im Issue werden keine Repository-Dateien oder Tests genannt; für den Abschluss wäre ein fokussiertes, abgestimmtes Design für das vorgeschlagene typing-Feature erforderlich, bevor der Implementierungsumfang festgelegt werden kann.