bpo-44863: In TypedDict allow inherit from Generic and preserve bases

Lib/test/_typed_dict_helper.py

@@ -10,9 +10,14 @@ class Bar(_typed_dict_helper.Foo, total=False):
 
 from __future__ import annotations
 
-from typing import Optional, TypedDict
+from typing import Generic, Optional, TypedDict, TypeVar
 
 OptionalIntType = Optional[int]
 
 class Foo(TypedDict):
     a: OptionalIntType
+
+OptionableT = TypeVar("OptionableT")
+
+class FooGeneric(TypedDict, Generic[OptionableT]):
+    a: Optional[OptionableT]

Lib/test/test_typing.py

@@ -2943,13 +2943,22 @@ def __add__(self, other):
 
 Label = TypedDict('Label', [('label', str)])
 
+TDG = TypeVar("TDG")
+
 class Point2D(TypedDict):
     x: int
     y: int
 
+class Point2DGeneric(Generic[TDG], TypedDict):
+    a: TDG
+    b: TDG
+
 class Bar(_typed_dict_helper.Foo, total=False):
     b: int
 
+class BarGeneric(_typed_dict_helper.FooGeneric[TDG], total=False):
+    b: int
+
 class LabelPoint2D(Point2D, Label): ...
 
 class Options(TypedDict, total=False):
@@ -4070,7 +4079,7 @@ def test_basics_functional_syntax(self):
         self.assertEqual(jim['id'], 1)
         self.assertEqual(Emp.__name__, 'Emp')
         self.assertEqual(Emp.__module__, __name__)
-        self.assertEqual(Emp.__bases__, (dict,))
+        self.assertIn(dict, Emp.__bases__)
         self.assertEqual(Emp.__annotations__, {'name': str, 'id': int})
         self.assertEqual(Emp.__total__, True)
 
@@ -4085,7 +4094,7 @@ def test_basics_keywords_syntax(self):
         self.assertEqual(jim['id'], 1)
         self.assertEqual(Emp.__name__, 'Emp')
         self.assertEqual(Emp.__module__, __name__)
-        self.assertEqual(Emp.__bases__, (dict,))
+        self.assertIn(dict, Emp.__bases__)
         self.assertEqual(Emp.__annotations__, {'name': str, 'id': int})
         self.assertEqual(Emp.__total__, True)
 
@@ -4135,7 +4144,7 @@ def test_py36_class_syntax_usage(self):
         self.assertEqual(LabelPoint2D.__name__, 'LabelPoint2D')
         self.assertEqual(LabelPoint2D.__module__, __name__)
         self.assertEqual(LabelPoint2D.__annotations__, {'x': int, 'y': int, 'label': str})
-        self.assertEqual(LabelPoint2D.__bases__, (dict,))
+        self.assertIn(dict, LabelPoint2D.__bases__)
         self.assertEqual(LabelPoint2D.__total__, True)
         self.assertNotIsSubclass(LabelPoint2D, typing.Sequence)
         not_origin = Point2D(x=0, y=1)
@@ -4157,6 +4166,17 @@ def test_pickle(self):
             EmpDnew = pickle.loads(ZZ)
             self.assertEqual(EmpDnew({'name': 'jane', 'id': 37}), jane)
 
+    def test_pickle_generic(self):
+        point = Point2DGeneric(a=5.0, b=3.0)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            z = pickle.dumps(point, proto)
+            point2 = pickle.loads(z)
+            self.assertEqual(point2, point)
+            self.assertEqual(point2, {'a': 5.0, 'b': 3.0})
+            ZZ = pickle.dumps(Point2DGeneric, proto)
+            Point2DGenericNew = pickle.loads(ZZ)
+            self.assertEqual(Point2DGenericNew({'a': 5.0, 'b': 3.0}), point)
+
     def test_optional(self):
         EmpD = TypedDict('EmpD', name=str, id=int)
 
@@ -4228,6 +4248,9 @@ def test_get_type_hints(self):
             {'a': typing.Optional[int], 'b': int}
         )
 
+    def test_get_type_hints_generic(self):
+        assert set(get_type_hints(BarGeneric)) == {'a', 'b'}
+
 
 class IOTests(BaseTestCase):
 

Lib/typing.py

@@ -2252,10 +2252,18 @@ def __new__(cls, name, bases, ns, total=True):
         Subclasses and instances of TypedDict return actual dictionaries.
         """
         for base in bases:
-            if type(base) is not _TypedDictMeta:
+            if not (type(base) is _TypedDictMeta or base is Generic):
                 raise TypeError('cannot inherit from both a TypedDict type '
                                 'and a non-TypedDict base class')
-        tp_dict = type.__new__(_TypedDictMeta, name, (dict,), ns)
+
+        generic_base = tuple(b for b in bases if b is Generic)
+        base_typevars = _collect_type_vars(ns.get("__orig_bases__", ()))
+        if not generic_base and base_typevars:
+            # If not directly inheriting from a Generic 
+            # but inheriting from a generic TypedDict
+            generic_alias = Generic.__class_getitem__(base_typevars),
+            generic_base = types.resolve_bases(generic_alias)
+        tp_dict = type.__new__(_TypedDictMeta, name, (*generic_base, dict,), ns)
 
         annotations = {}
         own_annotations = ns.get('__annotations__', {})