PEP 612在接受的答案之后被接受，现在我们在Python 3.10中有了typing.ParamSpec和typing.Concatenate。有了这些变量，我们可以正确地输入一些操纵位置参数的装饰器。
代码可以这样输入：

from typing import Callable, ParamSpec, Concatenate, TypeVar

Param = ParamSpec("Param")
RetType = TypeVar("RetType")

def get_authenticated_user()->str:
    return "John"

def inject_user() -> Callable[[Callable[Param, RetType]], Callable[Concatenate[str, Param], RetType]]:
    def decorator(func: Callable[Param, RetType]) -> Callable[Concatenate[str, Param], RetType]:
        def wrapper(user: str, *args:Param.args, **kwargs:Param.kwargs) -> RetType:
            user = get_authenticated_user()
            if user is None:
                raise Exception("Don't!")
            return func(*args, **kwargs)

        return wrapper

    return decorator

@inject_user()
def foo(a: int) -> bool:
    return bool(a % 2)

reveal_type(foo)  #  # I: Revealed type is "def (builtins.str, a: builtins.int) -> builtins.bool"

foo("user", 2)  # Type check OK
foo("no!")  # E: Missing positional argument "a" in call to "foo"  [call-arg]
foo(3)  # # E: Missing positional argument "a" in call to "foo"  [call-arg] # E: Argument 1 to "foo" has incompatible type "int"; expected "str"  [arg-type]

字符串

你不能用Callable来描述额外的参数，它们不是泛型的，你只能说你的装饰器接受一个Callable，然后返回一个不同的Callable。
在你的例子中，你可以用一个typevar来确定返回类型：

RT = TypeVar('RT')  # return type

def inject_user() -> Callable[[Callable[..., RT]], Callable[..., RT]]:
    def decorator(func: Callable[..., RT]) -> Callable[..., RT]:
        def wrapper(*args, **kwargs) -> RT:
            # ...

字符串
即使这样，当您使用reveal_type()时，最终的修饰foo()函数也具有def (*Any, **Any) -> builtins.bool*的类型签名。
目前正在讨论各种提案，以使Callable更加灵活，但这些提案尚未实现。

• Allow variadic generics
• Proposal: Generalize Callable to be able to specify argument names and kinds的
• TypeVar to represent a Callable's arguments的
• Support function decorators excellently的

列表中的最后一个是一个包含特定用例的伞票，它是修改可调用签名的装饰器：

修改返回类型或参数

对于一个任意的函数，你还不能这样做--甚至没有语法，这是我为它编的一些语法。

我在Pyright测试了这个。

from typing import Any, Callable, Type, TypeVar

T = TypeVar('T')

def typing_decorator(rtype: Type[T]) -> Callable[..., Callable[..., T]]:
    """
    Useful function to typing a previously decorated func.
    ```
    @typing_decorator(rtype = int)
    @my_decorator()
    def my_func(a, b, *c, **d):
        ...
    ```
    In Pyright the return typing of my_func will be int.
    """
    def decorator(function: Any) -> Any:
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            return function(*args, **kwargs)
        return wrapper
    return decorator  # type: ignore

字符串

使用decohints库可以解决这个问题：

pip install decohints

字符串
以下是它如何与您的代码一起工作：

from decohints import decohints

def get_authenticated_user():
    return "John"

@decohints
def inject_user():
    def decorator(func):
        def wrapper(*args, **kwargs):
            user = get_authenticated_user()
            if user is None:
                raise Exception("Don't!")
            return func(*args, user, **kwargs)  # <- call signature modified

        return wrapper

    return decorator

@inject_user()
def foo(a: int, username: str) -> bool:
    print(username)
    return bool(a % 2)

型
如果在PyCharm中输入foo()下面的内容并等待，它将显示foo函数参数提示(a: int, username: str)。
这里有一个decohints源代码的链接，还有其他解决这个问题的方法：https://github.com/gri-gus/decohints