Support type inference for `__orig_bases__` as defined in PEP 560

[huntzhan]

Is your feature request related to a problem? Please describe.
A clear and concise description of the problem.

__orig_bases__ is defined in PEP 560. Currently pyright does not infer the type of cls.__orig_bases__. For example,

from typing import Generic, TypeVar

T = TypeVar('T')


class Base(Generic[T]):
    pass


class Derived(Base[int]):
    pass


Derived.__orig_bases__

Hovering on the Derived.__orig_bases__ shows:

And the value of Derived.__orig_bases__ is (__main__.Base[int],)

Describe the solution you'd like
A clear and concise description of what you want to happen.

This feature is helpful for writing type reflection code. Would be great if inferring the type of cls.__orig_bases__ is supported.

Additional context
Add any other context or screenshots about the feature request here.

[hmc-cs-mdrissi]

I think this is an issue for typeshed. https://github.com/python/typeshed/blob/3ed7e3ba507c4a7a9aa8809df583af2c3a38ffe7/stdlib/builtins.pyi#L139 is where these need to be added. __orig_bases__/__mro_entries__ can both be added there. Should be a small pr.

[erictraut]

I agree that the typeshed stubs should include this symbol so it is not flagged as an illegal class member. It should probably be declared as type Sequence[type]. I'm going to close the issue here, but feel free to open a new issue or create a PR in typeshed. Pyright frequently pulls updates from the typeshed project.

[hmc-cs-mdrissi]

I experimented with adding this to typeshed in this pr. The main complication is __orig_bases__ is not defined on every type, but is defined only for Generic subclasses. So,

class Foo(Generic[T]):
...

Foo. __orig_bases__ exists but,

class Foo(object):
...

Foo.__orig_bases__ is an error of undefined attribute.

I tried adding it to Generic type stub, but looks like both mypy/pyright special case this type stub and it's unclear if it's possible to add it from typeshed.

[erictraut]

You may need to use a # type: ignore or a cast(Any, x).__orig_bases__. I still don't think this is used commonly enough to add special-case logic to type checkers. We could add it in the future if there is sufficient demand, but I think such demand will be unlikely.

[RobertCraigie]

For what it's worth I had to make use of __orig_bases__ here: https://github.com/RobertCraigie/prisma-client-py/blob/c988de2b1ee79124d6a65376492a4b9caaa0ea27/src/prisma/generator/generator.py#L136-L176 (InheritsGeneric is a protocol that defines __orig_bases__).

It's still niche but the use case is supporting this pattern without having to resort to code duplication to access the given type at runtime:

class Data(BaseModel):
    ...

class Generator(GenericGenerator[Data]):
    def generate(self, data: Data) -> None:
        ...

# if the `Data` class couldn't be magically resolved internally then it would have to be
# explicitly specified outside of a type annotation as well. Something like this:

class Generator(GenericGenerator[Data]):
    data_class: type[Data] = Data

    def generate(self, data: Data) -> None:
        ...

[kennipj]

We have a similar use case to @RobertCraigie's example. It is my understanding from reading python/typeshed#7827, that implementing support for this in typeshed is maybe not the best approach, as such I would hope that maybe we could see this added in pyright as a special case.

Having to use # type: ignore or a cast is not very ideal in my opinion.

[RobertCraigie]

@kennipj You can avoid having to use a # type: ignore or a cast by defining a custom type guard. For example:

from __future__ import annotations
from typing_extensions import TypeGuard, Protocol

class IndirectGenericSubclass(Protocol):
    __orig_bases__: tuple[_GenericAlias]

class _GenericAlias(Protocol):
    __origin__: type[object]

def is_indirect_generic_subclass(
    obj: object,
) -> TypeGuard[IndirectGenericSubclass]:
    bases = getattr(obj, '__orig_bases__') 
    return bases is not None and isinstance(bases, tuple)

# usage:
def foo(cls: type) -> None:
    if not is_indirect_generic_subclass(cls):
        raise ValueError('Expected class type to have an `__orig_bases__` attribute')
    print(cls.__orig_bases__)

While it's not ideal, this is better than casting or # type: ignoreing as it actually validates at runtime that the object has the __orig_bases__ attribute.

I'd hope that these protocols along with the type guard could be added to typing / typing_extensions but I expect that the maintainers won't want to document an implementation detail like this.

[AlexWaygood]

I'd hope that these protocols along with the type guard could be added to typing / typing_extensions but I expect that the maintainers won't want to document an implementation detail like this.

There's a third option: add a helper function to typing, similar to typing.get_args and typing.get_origin, which already exist (maybe it could be called typing.get_orig_bases?). The advantage of this solution is it means that implementation details can remain implementation details, but end users can still access the API that they need.

I'm not a maintainer of typing or typing_extensions, but I'm a contributor to both. I've personally never needed this API, but if multiple users are having this problem, I think it would be a reasonable feature request to CPython.