Annotating a decorator factory that can be applied to both classes and functions prevents pyright from correctly detecting types?

[ldorigo]

Note: the below is the result of a long process of debugging a library decorator that was hiding types. While I found a solution that works without changing pyright, I think the current behaviour might be incorrect and might cause errors elsewhere, so reporting it in case you want to fix.

Consider the following code:

from typing import Any, AsyncGenerator, Type, TypeVar, TypeVarTuple, cast, overload, Optional
from collections.abc import Callable


# Depending on how the generic variable is defined, I get different behaviours - see below 
C = TypeVar("C")
# C= TypeVar("C", bound=Callable[..., Any])
# C= TypeVar("C", bound=type)
# C = TypeVar("C", type, Callable[..., Any]) 


def mybeta(
    *,
    message: str = "",
) -> Callable[[C], C]:
    
    def decorator(func_or_class: C) -> C:
        if isinstance(func_or_class, type):
            print("class")

            return func_or_class
        
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            print("decorated")
            return func(*args, **kwargs)
        
        return cast(C, wrapper)
    return decorator
   
@mybeta(message="test")
def testfunc2(foo: str) -> str:
    return "testfunc2"

@mybeta(message="test")
async def testfunc2async(foo: str) -> str:
    return "testfunc2async"
    

@mybeta(message="test")
async def testfunc2asyncgen(foo: str) -> AsyncGenerator[str, None]:
    yield "testfunc2asyncgen"

@mybeta(message="test")
class TestClass:
    def __init__(self, foo: str) -> None:
        self.foo = foo

func2return = testfunc2("test")

async def ba():
    asyncfunc2return = await testfunc2async("test")

    async for asyncgenfunc2return in testfunc2asyncgen("test"):
           var = asyngenfunc2return 


testclass = TestClass("test")

Now:

• If I define C as C = TypeVar("C"): things work as expected, the variables have the expected types, except I cannot guard against decorating something that is not a class or a function.
• C= TypeVar("C", bound=Callable[..., Any]) also works, and since classes also happen to be callables, it works for my purpose above
• C= TypeVar("C", bound=type) also works as expected, decorating functions gives me an error in this case which is the expected behaviour
• C = TypeVar("C", type, Callable[..., Any]) this is the offending one: for some reason, the variables (func2return, asyncfunc2return, asynggenfunc2return and testclass) are now all of type Any.

VS Code extension or command-line
Pylance, but also tested it with https://pyright-play.net/ .

[erictraut]

A constrained TypeVar is not the right solution for this case. A bound TypeVar is fine is the right approach. If you want to provide an upper bound that supports type or Callable, you can use a union.

C = TypeVar("C", bound=Callable[..., Any] | type)