bpo-43923: Add support of generic typing.NamedTuple

Doc/library/typing.rst

@@ -1606,6 +1606,12 @@ These are not used in annotations. They are building blocks for declaring types.
  def __repr__(self) -> str:
  return f'<Employee {self.name}, id={self.id}>'
 
+ ``NamedTuple`` subclasses can be generic::
+
+ class Group(NamedTuple, Generic[T]):
+ key: T
+ group: list[T]
+
  Backward-compatible usage::
 
  Employee = NamedTuple('Employee', [('name', str), ('id', int)])
@@ -1624,6 +1630,9 @@ These are not used in annotations. They are building blocks for declaring types.
  Removed the ``_field_types`` attribute in favor of the more
  standard ``__annotations__`` attribute which has the same information.
 
+ .. versionchanged:: 3.11
+ Added support of multiple inheritance with :class:`Generic`.
+
 .. class:: NewType(name, tp)
 
  A helper class to indicate a distinct type to a typechecker,

Doc/whatsnew/3.11.rst

@@ -641,6 +641,13 @@ time
  (Contributed by Benjamin Szőke, Dong-hee Na, Eryk Sun and Victor Stinner in :issue:`21302` and :issue:`45429`.)
 
 
+typing
+------
+
+* :class:`~typing.NamedTuple` subclasses can be generic.
+ (Contributed by Serhiy Storchaka in :issue:`43923`.)
+
+
 unicodedata
 -----------
 

Lib/test/test_typing.py

@@ -5278,6 +5278,37 @@ class A:
  with self.assertRaises(TypeError):
  class X(NamedTuple, A):
  x: int
+ with self.assertRaises(TypeError):
+ class X(NamedTuple, tuple):
+ x: int
+ with self.assertRaises(TypeError):
+ class X(NamedTuple, NamedTuple):
+ x: int
+ class A(NamedTuple):
+ x: int
+ with self.assertRaises(TypeError):
+ class X(NamedTuple, A):
+ y: str
+
+ def test_generic(self):
+ class X(NamedTuple, Generic[T]):
+ x: T
+ self.assertEqual(X.__bases__, (tuple, Generic))
+ self.assertEqual(X.__orig_bases__, (NamedTuple, Generic[T]))
+ self.assertEqual(X.__mro__, (X, tuple, Generic, object))
+
+ A = X[int]
+ self.assertEqual(A.__bases__, (tuple, Generic))
+ self.assertEqual(A.__orig_bases__, (NamedTuple, Generic[T]))
+ self.assertEqual(A.__mro__, (X, tuple, Generic, object))
+ self.assertIs(A.__origin__, X)
+ self.assertEqual(A.__args__, (int,))
+ self.assertEqual(A.__parameters__, ())
+
+ a = A(3)
+ self.assertIs(type(a), X)
+ self.assertEqual(a.x, 3)
+
 
  def test_namedtuple_keyword_usage(self):
  LocalEmployee = NamedTuple("LocalEmployee", name=str, age=int)

Lib/typing.py

@@ -2763,7 +2763,12 @@ def _make_nmtuple(name, types, module, defaults = ()):
 class NamedTupleMeta(type):
 
  def __new__(cls, typename, bases, ns):
- assert bases[0] is _NamedTuple
+ assert _NamedTuple in bases
+ for base in bases:
+ if base is not _NamedTuple and base is not Generic:
+ raise TypeError('can only inherit from a NamedTuple type '
+ 'and Generic')
+ bases = tuple(tuple if base is _NamedTuple else base for base in bases)
  types = ns.get('__annotations__', {})
  default_names = []
  for field_name in types:
@@ -2777,6 +2782,7 @@ def __new__(cls, typename, bases, ns):
  nm_tpl = _make_nmtuple(typename, types.items(),
  defaults=[ns[n] for n in default_names],
  module=ns['__module__'])
+ nm_tpl.__bases__ = bases
  # update from user namespace without overriding special namedtuple attributes
  for key in ns:
  if key in _prohibited:
@@ -2820,9 +2826,7 @@ class Employee(NamedTuple):
 _NamedTuple = type.__new__(NamedTupleMeta, 'NamedTuple', (), {})
 
 def _namedtuple_mro_entries(bases):
- if len(bases) > 1:
- raise TypeError("Multiple inheritance with NamedTuple is not supported")
- assert bases[0] is NamedTuple
+ assert NamedTuple in bases
  return (_NamedTuple,)
 
 NamedTuple.__mro_entries__ = _namedtuple_mro_entries

Misc/NEWS.d/next/Library/2022-04-28-18-45-58.gh-issue-88089.hu9kRk.rst

@@ -0,0 +1,2 @@
+Add support of multiple inheritance of :class:`typing.NamedTuple` with
+:class:`typing.Generic`.