How to accurately use a function as a type?

[Dreamsorcerer]

I'm really not sure what to search for, so I apologise if this has already been covered.

We're trying to type check our tests with a function that is passed through a fixture. The problem is how to annotate the fixture to get the function type correctly. Here's a snippet of the code we're currently using:

from propcache.api import under_cached_property

class APIProtocol(Protocol):
    under_cached_property: type[under_cached_property]

def test_under_cached_property(propcache_module: APIProtocol) -> None:
    class A:
        def __init__(self) -> None:
            self._cache: dict[str, int] = {}

        @propcache_module.under_cached_property
        def prop(self) -> int:
            return 1

The problem is that there is a Generic in the function signature. So, this code actually infers that generic as Any (i.e. type[under_cached_property[Any]]) and then the return type of the .prop() method becomes Any too.

If we were to add a TypeVar and use APIProtocol[T], then mypy gives an error that it was expecting T and not int when using the decorator.

Is there any way to declare the type as exactly the function, so any generics are handled the same way as using the function directly? Failing that, any tips on how to workaround this? I really want type checking on these tests as we've already missed serious type checking failures due to this issue.

The reason for the fixture is that the tests are executed twice with Python and Cython implementations of the modules.

[Daverball]

I believe what you want is this:

class APIProtocol(Protocol):
    def under_cached_property(self, method: Callable[[Any], T]) -> under_cached_property[T]: ...

You want under_cached_property to be a generic method, rather than the entire protocol being generic.

[Dreamsorcerer]

I think that's a major improvement, but it does mean that we're not type checking the implementation's Callable parameter now. If nobody has any better ideas though, then I'll use this which atleast seems to catch the type errors we were missing before.

[Daverball]

You could write a separate type test that just uses under_cached_property directly that verifies some common usage/failure patterns using assert_type and type:ignore with warn_unused_ignore. Doesn't even really need to be a pytest test case, it can just be some code inside an if TYPE_CHECKING block.

Alternatively you could do something like:

if not TYPE_CHECKING:
    under_cached_property = propcache_module.under_cached_property

And then use under_cached_property instead of propcache_module.under_cached_property in the test.

Although that of course adds a bit of boiler plate to every test case and defeats some of the purpose of using a test fixture.