To quote the documentation for typing.ParamSpec:

P.args [...] should only be used to annotate *args. P.kwargs [...] should be only be used to annotate **kwargs.

So this is not possible to with ParamSpec.

The idea of being able to use P.args/P.kwargs in other scopes is not new. But there are fundamental problems that with that, which are unlikely to be solved with ParamSpec as is. Actually PEP 612 mentioned the underlying issue briefly, explaining the reason for why ParamSpec was introduced in the first place:

The core problem here is that, by default, parameters in Python can either be called positionally or as a keyword argument. This means we really have three categories (positional-only, positional-or-keyword, keyword-only) we’re trying to jam into two categories. [...] Fundamentally, in order to capture two categories when there are some things that can be in either category, we need a higher level primitive (ParamSpec) to capture all three, and then split them out afterward.

A good example was given by someone in the aforementioned issue:

def foo(x: int) -> None: ...
def get_callable_and_args(x: Callable[P, Any]) -> Tuple[P.args, P.kwargs]: ...

reveal_type(get_callable_and_args(foo))  # <- What should this reveal?

Should we reveal a tuple of int + empty dict? Or should we reveal an empty tuple and a singleton dict that maps x to int? [...] the existence of "positional-or-keyword" arguments in Python makes things highly ambiguous. [...] To fully resolve this kind of issue, there needs to be a way in the type system to represent positional-only, positional-or-keyword, and keyword-only parameters separately. But at that point, it's going to be a different language feature, not ParamSpec anymore.

So I would not hold my breath for ParamSpec to support this any time soon.

If we were talking only about positional arguments, what you want there would be possible with the TypeVarTuple. PEP 646 specifically suggests they can be used as Callable arguments.

Something like this should then be possible:

from collections.abc import Callable
from typing import Any, TypeVarTuple

Ts = TypeVarTuple("Ts")


def test_function(func: Callable[[*Ts], Any], args: list[tuple[*Ts]]) -> None:
    for a in args:
        func(*a)

I say should because it is still hard to verify since mypy does not fully support PEP 646 yet.

But even so, no support for keyword-arguments. Basically, as soon as a combination of the three different parameter categories comes up, things get tricky fast.

if the parameters match exactly you can use this 1-1, if there's a mismatch you would need to also use Concatenate and modify it a bit, i have yet to find a generic solution for that case. this is a modified version of the above answer from @Daniil Fajnberg

from typing import TypeVar, ParamSpec, Callable

P = ParamSpec("P")
T = TypeVar("T")
S = TypeVar("S")

def paramspec_from(_: Callable[P, T]) -> Callable[[Callable[P, S]], Callable[P, S]]:
    def _fnc(fnc: Callable[P, S]) -> Callable[P, S]:
        return fnc
    return _fnc

then you can use it like this:

@paramspec_from(known_function)
def wrapper(*args, **kwargs) -> string:
    foo()
    known_function(*args, **kwargs)
    return "whatever"

The problem is that mypy only looks at the function header to resolve the ParamSpec, not the function body, so it cannot deduce the types of args and kwargs. but if we lift the function into the header, like by passing it into the decorator as an argument, mypy can deduce the parameters correctly. As you see we don't even use the function, we marked it with _. we only use it for its typehints.

Firstly, some notes about limitations of ParamSpec and Concatenate:

• Concatenate requires you to always put the argument that is to be taken first in the list, and the final arg must be the ParamSpec.

• A good way to think about it is that the wrapper "consumes" the first argument, and always expects a function that has a certain structure.

The below example type checks fine for me in pyright/pylance/mypy. I've introduced a few of the classes to check everything type checks - and the return type of "out" is User so it seems fine:

import asyncio
from typing import Any, Callable, Concatenate, Coroutine, cast
import contextlib
from uuid import UUID

@contextlib.asynccontextmanager
async def aclosing():
    try:
        yield AsyncConnection()
    finally:
        pass

class AsyncConnection[T]:
    def cursor(self):
        return aclosing()

class DbDriver:
    def connection(self):
        return aclosing()

def ensure_connR, **P -> Callable[P, Coroutine[Any, Any, R]]:
    """Ensure the function has a conn argument. If conn is not provided, generate a new connection and pass it to the function."""

    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        # Get named keyword argument conn, or find an AsyncConnection in the args
        kwargs_conn = kwargs.get("conn")
        conn_arg: AsyncConnection[Any] | None = None
        if isinstance(kwargs_conn, AsyncConnection):
            conn_arg = kwargs_conn
        elif not conn_arg:
            for arg in args:
                if isinstance(arg, AsyncConnection):
                    conn_arg = arg
                    break
        if conn_arg:
            # If conn is provided, call the method as is
            return await func(conn_arg, *args, **kwargs)
        else:
            # If conn is not provided, generate a new connection and pass it to the method
            db_driver = DbDriver()
            async with db_driver.connection() as conn:
                return await func(conn, *args, **kwargs)

    return wrapper

class User:
    def __init__(self, uuid: UUID) -> None:
        self.uuid=uuid

@ensure_conn
async def get_user(conn: AsyncConnection, user_id: UUID):
    async with conn.cursor() as cursor:
        return User(user_id)

async def main():
    uuid: UUID = cast(UUID, '519766c5-af86-47ea-9fa9-cee0c0de66b1')
    out = await get_user(uuid)

asyncio.run(main())

Hope this helps!

I don't see a way to do this if you want to preserve the ability to use the first parameter as a keyword parameter. If you're willing to assume that the first parameter is always used as a positional-only parameter, then you can use Concatenate.

def add_logging_with_first_arg(
    f: Callable[Concatenate[str, P], T]
) -> Callable[Concatenate[str, P], T]: ...

There is surprisingly little about this online. I was able to find someone else's discussion of this over at python/typing's Github, which I distilled using your example.

The crux of this solution is Callback Protocols, which are functionally equivalent to Callable, but additionally enable us to modify the return type of __get__ (essentially removing the self parameter) as is done for standard methods.

from __future__ import annotations

from typing import Any, Callable, Concatenate, Generic, ParamSpec, Protocol, TypeVar

from requests import Request

P = ParamSpec("P")
R = TypeVar("R", covariant=True)


class Method(Protocol, Generic[P, R]):
    def __get__(self, instance: Any, owner: type | None = None) -> Callable[P, R]:
        ...

    def __call__(self_, self: Any, *args: P.args, **kwargs: P.kwargs) -> R:
        ...


def request_wrapper(f: Callable[Concatenate[Any, Request, P], R]) -> Method[P, R]:
    def inner(self, *args: P.args, **kwargs: P.kwargs) -> R:
        return f(self, Request(), *args, **kwargs)

    return inner


class Thing:
    @request_wrapper
    def takes_int_str(self, request: Request, x: int, y: str) -> int:
        print(request)
        return x + 7


thing = Thing()
thing.takes_int_str(1, "a")

Since @Creris asked about the mypy error raised from the definition of inner, which is an apparent bug in mypy w/ ParamSpec and Callback Protocols as of mypy==0.991, here is an alternate implementation with no errors:

from __future__ import annotations

from typing import Any, Callable, Concatenate, ParamSpec, TypeVar

from requests import Request

P = ParamSpec("P")
R = TypeVar("R", covariant=True)


def request_wrapper(f: Callable[Concatenate[Any, Request, P], R]) -> Callable[Concatenate[Any, P], R]:
    def inner(self: Any, *args: P.args, **kwargs: P.kwargs) -> R:
        return f(self, Request(), *args, **kwargs)

    return inner


class Thing:
    @request_wrapper
    def takes_int_str(self, request: Request, x: int, y: str) -> int:
        print(request)
        return x + 7


thing = Thing()
thing.takes_int_str(1, "a")