Is it possible to narrow between generic type[_T] and Callable[[Any], _T]?

[aakhavanQC]

I have a library that looks something like this:

from typing import Generic, TypeVar, Any, Protocol, Self, runtime_checkable

@runtime_checkable
class ValidatesResponses(Protocol):
    @classmethod
    def validate_response(cls, response: Any) -> Self: ...

_T = TypeVar("_T")


class RemoteFunction(Generic[_T]):
    def __init__(self, return_type: type[_T]):
        self._return_type = return_type

    def _validate(self, response: Any) -> _T:
        if issubclass(self._return_type, ValidatesResponses):
            return self._return_type.validate_response(response)

        if not isinstance(response, self._return_type):
            raise TypeError
        
        return response

    # would usually have arguments
    def __call__(self) -> _T:
        remote_response: Any = None # actually from network/db/etc
        return self._validate(remote_response)

# Usage example
my_remote_func = RemoteFunction(int)
response: int = my_remote_func()

The basic idea is to strongly type functions that are actually run outside of python by validating the response. Currently, you can give it either the return type as an argument, or a class with a validate_response class method that returns an instance of the class (convenient for validation with pydantic, for example). The problem with this approach is that it forces the validation function to return an instance of the same class it belongs to because it prevents you from easily being able to deeply validate lists/dicts.

To address this, I want to change return_type to be Callable[[Any], _T]. This means it will take any function whose return type matches the class generic type. The downside, though, is you can no longer give it primitives like the RemoteFunction(int) example. So I tried type[_T] | Callable[[Any], _T], but I can't figure out how to get the type checker to distinguish between something that's built-in vs something that's actually a function. I know I could hardcode the primitive types, but worry that it's risky in that I might miss something.

Ultimately what I'm looking for is something like this:

class RemoteFunction(Generic[_T]):
    def __init__(self, return_type: type[_T] | Callable[[Any], _T]):
        self._return_type = return_type

    def _validate(self, response: Any) -> _T:
        if isinstance(self._return_type, type):
            reveal_type(self._return_type) # Type of "self._return_type" is "type[object] | type"
            if not isinstance(response, self._return_type):
                raise TypeError
            reveal_type(response) # Type of "response" is "Any"
            return response

        return self._return_type(response)

which allows both

# Usage example
my_remote_func = RemoteFunction(int)
response: int = my_remote_func()

and

my_other_remote_func = RemoteFunction(pydantic.BaseModel.model_validate)
response: BaseModel = my_other_remote_func

Interestingly, pyright seems to correctly gets that response in the example is an int, even though it's Any in the scope of the method (mypy throws an error there though: # Incompatible return value type (got "object", expected "_T"))