How to Type Hint part of *args

[hmc-cs-mdrissi]

I have a function where I know what the first positional argument type should be, but the remaining ones are undefined. Is there any way to specify only the first argument? The exact function signature is,

def f(*args, **kwargs):
...

and the type I want is roughly like

def f(args: [int, Any], **kwargs: Any) -> int:
pass

So even though most of the types are Any, the return type and first input type are known and those are the most important ones to me (partly as other arguments are rare). It's reasonable to argue that I should refactor an argument out, but I mostly am curious about this type hint for a key function in a large 3rd party library and changing its signature is unlikely. If there's no other way then I'll make a wrapper around it for actual usage.

[erictraut]

If I understand you correctly, the signature would be this:

def f(_p0: int, *args: Any, **kwargs: Any) -> int:
    ...

Or are you asking how to specify this as a Callable type annotation? Callable doesn't allow this combination. (You can specify Callable[..., int], but there's no way to indicate that the first parameter should be an int.)

Although Callable is somewhat limiting, you can escape those limits by using a callback protocol. It would look like this:

class CallbackWithInt(Protocol):
    def __call__(self, _p0: int, *args: Any, **kwargs: Any) -> int:
        ...

[hmc-cs-mdrissi]

The main awkwardness is the exact signature of f being f(*args, **kwargs) I'd like to keep if possible as it's a method from a class I'm subclassing. I know python allows you to ignore superclass signature freely, it just feels like a potential foot-gun. I will do that if it's the only/best option. I initially skimmed paramspec hoping concatenate would do what I want but doesn't seem like *args: Concatenate[int, P.args] is intended.

[erictraut]

Yeah, ParamSpec and Concatenate won't work for this situation.

As you said, you can override the method in the superclass with a different signature, but it is a bit unsafe. In "strict" mode, pyright will emit an error for this condition, so you'd need to disable this error.

# pyright: strict, reportIncompatibleMethodOverride=false

from typing import Any

class Parent:
    def f(self, *args: Any, **kwargs: Any) -> int:
        ...

class Child(Parent):
    def f(self, _p0: int, *args: Any, **kwargs: Any) -> int:
        return super().f(_p0, *args, **kwargs)