How to specialize the first argument of ParamSpec args

[lexdene]

In the following code,
I think add_logging_with_first_arg is a special case of add_logging which specializes the first argument of ParamSpec.args to str.

How should I write the type annotations for add_logging_with_first_arg?

from collections.abc import Callable
from typing import TypeVar, ParamSpec

T = TypeVar('T')
P = ParamSpec('P')

def add_logging(name: str) -> Callable[[Callable[P, T]], Callable[P, T]]:
    def wrapper(f: Callable[P, T]) -> Callable[P, T]:
        def inner(*args: P.args, **kwargs: P.kwargs) -> T:
            print(f'{name}: {f.__name__} was called')
            return f(*args, **kwargs)
        return inner
    return wrapper

def add_logging_with_first_arg(f):
    def inner(app_name: str, *argv, **kwargs):
        _wrapper = add_logging(app_name)(f)
        return _wrapper(app_name, *argv, **kwargs)

    return inner

@add_logging('first')
def foo1(num: int) -> None:
    pass

@add_logging('second')
def foo2() -> None:
    pass

@add_logging_with_first_arg
def foo3(app_name: str, num: int) -> None:
    pass

@add_logging_with_first_arg
def foo4(app_name: str) -> None:
    pass

def main() -> None:
    foo1(37)
    foo2()
    foo3('hello', 37)
    foo3(app_name='hello', num=37)
    foo4('world')
    foo4(app_name='world')

main()

[erictraut]

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]: ...