More tests and docs following python#103698

Author: AlexWaygood

Doc/library/types.rst

@@ -96,19 +96,27 @@ Dynamic Type Creation
 
     Examples::
 
-        from typing import TypeVar, Generic
+        from typing import TypeVar, Generic, NamedTuple, TypedDict
 
         T = TypeVar("T")
         class Foo(Generic[T]): ...
         class Bar(Foo[int], float): ...
         class Baz(list[str]): ...
+        Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
+        Spam = TypedDict("Spam", {"a": int, "b": str})
 
         assert Bar.__bases__ == (Foo, float)
         assert get_original_bases(Bar) == (Foo[int], float)
 
         assert Baz.__bases__ == (list,)
         assert get_original_bases(Baz) == (list[str],)
 
+        assert Eggs.__bases__ == (tuple,)
+        assert get_original_bases(Eggs) == (NamedTuple,)
+
+        assert Spam.__bases__ == (dict,)
+        assert get_original_bases(Spam) == (TypedDict,)
+
         assert int.__bases__ == (object,)
         assert get_original_bases(int) == (object,)
 

Lib/test/test_types.py

@@ -1378,10 +1378,45 @@ class F(list[int]): pass
         self.assertEqual(types.get_original_bases(E), (list[T],))
         self.assertEqual(types.get_original_bases(F), (list[int],))
 
-        class G(typing.NamedTuple):
+        class ClassBasedNamedTuple(typing.NamedTuple):
             x: int
 
-        self.assertIs(types.get_original_bases(G)[0], typing.NamedTuple)
+        class GenericNamedTuple(typing.NamedTuple, typing.Generic[T]):
+            x: T
+
+        CallBasedNamedTuple = typing.NamedTuple("CallBasedNamedTuple", [("x", int)])
+
+        self.assertIs(
+            types.get_original_bases(ClassBasedNamedTuple)[0], typing.NamedTuple
+        )
+        self.assertEqual(
+            types.get_original_bases(GenericNamedTuple),
+            (typing.NamedTuple, typing.Generic[T])
+        )
+        self.assertIs(
+            types.get_original_bases(CallBasedNamedTuple)[0], typing.NamedTuple
+        )
+
+        class ClassBasedTypedDict(typing.TypedDict):
+            x: int
+
+        class GenericTypedDict(typing.TypedDict, typing.Generic[T]):
+            x: T
+
+        CallBasedTypedDict = typing.TypedDict("CallBasedTypedDict", {"x": int})
+
+        self.assertIs(
+            types.get_original_bases(ClassBasedTypedDict)[0],
+            typing.TypedDict
+        )
+        self.assertEqual(
+            types.get_original_bases(GenericTypedDict),
+            (typing.TypedDict, typing.Generic[T])
+        )
+        self.assertIs(
+            types.get_original_bases(CallBasedTypedDict)[0],
+            typing.TypedDict
+        )
 
         with self.assertRaisesRegex(TypeError, "Expected an instance of type"):
             types.get_original_bases(object())

Lib/types.py

@@ -149,15 +149,19 @@ def get_original_bases(cls, /):
 
     Examples::
 
-        from typing import TypeVar, Generic
+        from typing import TypeVar, Generic, NamedTuple, TypedDict
 
         T = TypeVar("T")
         class Foo(Generic[T]): ...
         class Bar(Foo[int], float): ...
         class Baz(list[str]): ...
+        Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
+        Spam = TypedDict("Spam", {"a": int, "b": str})
 
         assert get_original_bases(Bar) == (Foo[int], float)
         assert get_original_bases(Baz) == (list[str],)
+        assert get_original_bases(Eggs) == (NamedTuple,)
+        assert get_original_bases(Spam) == (TypedDict,)
         assert get_original_bases(int) == (object,)
     """
     try: