Python: Typecheck functions that forward *args, **kwargs without a wrapping decorator (PEP 612)

Question

PEP612 adds ParameterSpec to the typing module, allowing you to type-check functions that are wrapped by function decorators (and type-check the decorators themselves with the help of Concatenate).

In one of the discussions leading to acceptance of the PEP, scenarios where functions simply forwarded *args, **kwargs to other functions were cited, but from what I can tell, this is still not supported unless you are using a decorator because ParamSpec can only be used when a Callable type is already in-scope.

For example, I don't know how any of the following fits in (if at all):

def plot_special(df: pd.DataFrame, p1: int, p2: int, *plot_args, **plot_kwargs) -> None:
   # do something with p1, p2
   df.plot(*plot_args, **plot_kwargs)

or

class A:
   def f(self, x: int, y: int) -> int:
      return x + y

class B:
   def __init__(self) -> None:
      self.a = A()

   f = A.a # Does not work, self is not of type A

   # Since B.f is not wrapping A.f, does not seem to be a way
   # to contextualize a ParameterSpec
   def f(self, *args, **kwargs) -> int:
      self.a.f(*args, **kwargs)

or

class A:
    def __int__(self, p1: int, p2: int) -> None:
      self.p1 = p1
      self.p2 = p2

   def f(x: int, y: int) -> int:
      return x + y

class MixinForA:
   def __init__(self, p3: str, *args, **kwargs) -> None:
      self.p3 = p3
      super().__init__(*args, **kwargs)

Unless *args and **kwargs are homogeneous, it seems we're still unable to take advantage of type-checking functions that a invoked from other functions where those functions wish to only pass along *args, **kwargs (instead of duplicating the function signatures).

user_7002298 · Answer

I was asking myself exactly the same question. I'm no expert, but I do believe like you that the API given by ParamSpec does not cover the simple "wrapper" use case.

My interpretation is that we miss a syntaxical way to tell "those arguments will be used by such internal statement"; the syntax available today is easier because all the information is contained in the signature.

However (I'm quite proud of it), I discovered than you can "cheat" a bit and have it work, by writing a one-time use decorator. It might be useful in some use cases (though I trust some good pythonist will be able to spin up a further PEP one day that would render this code useless)

# demo wrapper
# objective: write a type-checked function
# that calls inner()

import typing as tp
import typing_extensions as tp_ext

P = tp_ext.ParamSpec("P") # arguments
T = tp.TypeVar("T") # return type

def inner(a: int, b: float, *, c: str) -> bool:
    return True


def outer_naive(verbose:bool, *args, **kwargs) -> bool:
    if verbose:
        print("Got arguments!", args, kwargs)
    return inner(*args, **kwargs)

# pass type checks, 
# even though it would fail at runtime because a,b,c are missing
outer_naive(verbose=True)

def outer_factory(to_wrap: tp.Callable[P, T]) -> tp.Callable[tp_ext.Concatenate[bool, P],T]:
    def outer_aware(verbose: bool, *args: P.args, **kwargs: P.kwargs) -> T:
        if verbose:
            print("Got arguments!", args, kwargs)
        return to_wrap(*args, **kwargs)
    return outer_aware

outer_with_type = outer_factory(inner)

# fails type check ! 
# Pyright successfully inferred the need for the 3 arguments a,b,c
inner(True)

# fails type check
inner(True, "should be an int", 2.5, c="hey")

# pass type check
inner(True, 1, 1.0, c="hey")

Here's a screenshot of the feedback I get with VSCode + Pylance for the last lines:

Python: Typecheck functions that forward *args, **kwargs without a wrapping decorator (PEP 612)

1 Answers