Add typing for a staticmethod in a python class

Question

In a class Foo I link a static method in a class variable to subclass that class later and just exchange that function with another. The class contains some methods which call this exchangable function. The code below does not produce any mypy issues.

def some_function(text: str) -> None:
    print(text)

class Foo:
    _some_func: ClassVar[staticmethod] = staticmethod(some_function)

    def some_method(self, text: str) -> None:
        self._some_func(text)

if __name__ == "__main__":
    Foo().some_method("Hello World!")

Now, I am trying to improve my typing, so I want to use a callback protocol to actually add typing for Foo._some_func. I have created the following protocol class:

class SomeFuncProtocol(Protocol):
    def __call__(self, __text: str) -> None:
        ...

It does work as long as I use _some_func: ClassVar[SomeFuncProtocol] = some_function, but I can't find a way to use staticmethod and the protocol class for typing. I wish for something like the following, but mypy tells me that staticmethod does not expect a type argument.

class Foo:
   _some_func: ClassVar[staticmethod[SomeFuncProtocol]] = staticmethod(some_function)
   ...

Does anybody know how to do it?

Answer 1

I was stuck with similar thing for a while, here's what worked for me:

from typing import ClassVar, Protocol

def some_function(text: str) -> None:
    print(text)

class SomeFuncProtocol(Protocol):
    def __call__(self, __text: str) -> None:
        return

class Foo:
   _some_func: ClassVar[SomeFuncProtocol] = staticmethod(some_function)

Foo._some_func('a')
Foo()._some_func('a')
Foo._some_func = some_function
Foo()._some_func = some_function  # E: Cannot assign to class variable "_some_func" via instance

The code above typechecks (except for last line that is intentionally incorrect).

You don't need staticmethod in type annotation: it's a function that (simplified) takes callable as argument and returns another callable with same signature, but with explicit sign that it doesn't accept self. So return type of staticmethod is the same callable, we can express it like this:

from typing import Any, Callable, TypeVar
_C = TypeVar('_C', bound=Callable[..., Any])
def staticmethod(func: _C) -> _C: ...

You can try it in playground.