gh-101688: Implement types.get_original_bases

Doc/library/typing.rst

@@ -2804,6 +2804,47 @@ Introspection helpers
 
    .. versionadded:: 3.8
 
+.. function:: get_orig_bases(tp, /)
+
+    Returns the objects in the bases list in the class's definition before
+    they were modified by ``__mro_entries__``. This is useful for
+    introspecting ``Generic``\s.
+
+    Examples::
+
+        T = TypeVar("T")
+
+        class Foo(Generic[T]): ...
+
+        class Bar(Foo[int], float): ...
+
+        get_orig_bases(Foo) == (Generic[T],)
+        get_orig_bases(Bar) == (Foo[int], float)
+        get_orig_bases(int) == None
+
+    .. versionadded:: 3.12
+
+.. function:: get_orig_class(tp, /)
+
+    Returns the ``GenericAlias`` object that was instantiated to create ``tp``.
+
+    Examples::
+
+        T = TypeVar("T")
+
+        class Foo(Generic[T]): ...
+
+        get_orig_class(Foo[int]()) == Foo[int]
+        get_orig_class(list[int]()) == None
+        get_orig_class(int) == None
+
+    .. warning::
+
+        This function will always return ``None`` inside of the class initalisation
+        process.
+
+    .. versionadded:: 3.12
+
 .. function:: is_typeddict(tp)
 
    Check if a type is a :class:`TypedDict`.

Lib/test/test_typing.py

@@ -22,7 +22,7 @@
 from typing import Generic, ClassVar, Final, final, Protocol
 from typing import assert_type, cast, runtime_checkable
 from typing import get_type_hints
-from typing import get_origin, get_args
+from typing import get_origin, get_args, get_orig_bases, get_orig_class
 from typing import is_typeddict
 from typing import reveal_type
 from typing import dataclass_transform
@@ -5355,6 +5355,32 @@ class C(Generic[T]): pass
         self.assertEqual(get_args((*tuple[*Ts],)[0]), (*Ts,))
         self.assertEqual(get_args(Unpack[tuple[Unpack[Ts]]]), (tuple[Unpack[Ts]],))
 
+    def test_get_orig_class(self):
+        T = TypeVar('T')
+        class C(Generic[T]): pass
+        class D(C[int]): ...
+        class E(C[str], float): pass
+        self.assertEqual(get_orig_class(C[int]()), C[int])
+        self.assertIsNone(get_orig_class(C()))
+        self.assertIsNone(get_orig_class(D()))
+        self.assertIsNone(get_orig_class(E()))
+        self.assertIsNone(get_orig_class(list[int]()))
+        self.assertIsNone(get_orig_class(int))
+
+    def test_get_orig_bases(self):
+        T = TypeVar('T')
+        class A: pass
+        class B(object): pass
+        class C(Generic[T]): pass
+        class D(C[int]): pass
+        class E(C[str], float): pass
+        self.assertIsNone(get_orig_bases(A))
+        self.assertIsNone(get_orig_bases(B))
+        self.assertEqual(get_orig_bases(C), (Generic[T],))
+        self.assertEqual(get_orig_bases(D), (C[int],))
+        self.assertIsNone(get_orig_bases(int))
+        self.assertEqual(get_orig_bases(E), (C[str], float))
+
 
 class CollectionsAbcTests(BaseTestCase):
 

Lib/typing.py

@@ -127,6 +127,8 @@ def _idfunc(_, x):
     'final',
     'get_args',
     'get_origin',
+    'get_orig_bases',
+    'get_orig_class',
     'get_overloads',
     'get_type_hints',
     'is_typeddict',
@@ -2446,6 +2448,49 @@ def get_args(tp):
     return ()
 
 
+def get_orig_bases(tp: "Any", /) -> tuple[type["Any"], ...] | None:
+    """Get the __orig_bases__ (see PEP 560) of a class.
+
+    Examples::
+
+        class Foo(Generic[T]): ...
+
+        class Bar(Foo[int]): ...
+
+        get_orig_bases(Foo) == Generic[T]
+        get_orig_bases(Bar) == Foo[int]
+        get_orig_bases(int) == None
+    """
+    if isinstance(tp, type):
+        try:
+            return tp.__orig_bases__
+        except AttributeError:
+            pass
+    return None
+
+
+def get_orig_class(tp: "Any", /) -> GenericAlias | None:
+    """Get the __orig_class__ for an instance of a Generic subclass.
+
+    Examples::
+
+        class Foo(Generic[T]): ...
+
+        get_orig_class(Foo[int]()) == Foo[int]
+        get_orig_class(list[int]()) == None
+        get_orig_class(int) == None
+
+    Warning
+    -------
+    This will always return None in the inside of the class initalisation
+    process.
+    """
+    try:
+        return tp.__orig_class__
+    except AttributeError:
+        return None
+
+
 def is_typeddict(tp):
     """Check if an annotation is a TypedDict class
 

Misc/NEWS.d/next/Library/2023-02-11-15-01-32.gh-issue-101688.kwXmfM.rst

@@ -0,0 +1 @@
+Implement :func:`typing.get_orig_bases` and :func:`typing.get_orig_class` to provide further introspection for types