NoExtraItems

Author: JelleZijlstra

src/test_typing_extensions.py

@@ -54,6 +54,7 @@
     Never,
     NewType,
     NoDefault,
+    NoExtraItems,
     NoReturn,
     NotRequired,
     Optional,
@@ -4030,7 +4031,7 @@ def test_keywords_syntax_raises_on_3_13(self):
         with self.assertRaises(TypeError), self.assertWarns(DeprecationWarning):
             TypedDict('Emp', name=str, id=int)
 
-    @skipIf(sys.version_info >= (3, 13), "3.13 removes support for kwargs")
+    @skipIf(sys.version_info >= (3, 15), "3.15 removes support for kwargs")
     def test_basics_keywords_syntax(self):
         with self.assertWarns(DeprecationWarning):
             Emp = TypedDict('Emp', name=str, id=int)
@@ -4047,14 +4048,18 @@ def test_basics_keywords_syntax(self):
         self.assertEqual(Emp.__annotations__, {'name': str, 'id': int})
         self.assertEqual(Emp.__total__, True)
 
-    @skipIf(sys.version_info >= (3, 13), "3.13 removes support for kwargs")
+    @skipIf(sys.version_info >= (3, 15), "3.15 removes support for kwargs")
     def test_typeddict_special_keyword_names(self):
         with self.assertWarns(DeprecationWarning):
             TD = TypedDict("TD", cls=type, self=object, typename=str, _typename=int,
-                           fields=list, _fields=dict)
+                           fields=list, _fields=dict,
+                           closed=bool, extra_items=bool)
         self.assertEqual(TD.__name__, 'TD')
         self.assertEqual(TD.__annotations__, {'cls': type, 'self': object, 'typename': str,
-                                              '_typename': int, 'fields': list, '_fields': dict})
+                                              '_typename': int, 'fields': list, '_fields': dict,
+                                              'closed': bool, 'extra_items': bool})
+        self.assertIs(TD.__closed__, False)
+        self.assertIs(TD.__extra_items__, NoExtraItems)
         a = TD(cls=str, self=42, typename='foo', _typename=53,
                fields=[('bar', tuple)], _fields={'baz', set})
         self.assertEqual(a['cls'], str)
@@ -4323,14 +4328,31 @@ class ChildUnclosed(Closed, Unclosed):
                 ...
 
         self.assertFalse(ChildUnclosed.__closed__)
-        self.assertEqual(ChildUnclosed.__extra_items__, type(None))
+        self.assertEqual(ChildUnclosed.__extra_items__, NoExtraItems)
 
         with self.assertWarns(DeprecationWarning):
             class ChildClosed(Unclosed, Closed):
                 ...
 
         self.assertFalse(ChildClosed.__closed__)
-        self.assertEqual(ChildClosed.__extra_items__, type(None))
+        self.assertEqual(ChildClosed.__extra_items__, NoExtraItems)
+
+    def test_extra_items_class_arg(self):
+        class TD(TypedDict, extra_items=int):
+            a: str
+
+        self.assertEqual(TD.__extra_items__, int)
+        self.assertEqual(TD.__annotations__, {'a': str})
+        self.assertEqual(TD.__required_keys__, frozenset({'a'}))
+        self.assertEqual(TD.__optional_keys__, frozenset())
+
+        class NoExtra(TypedDict):
+            a: str
+
+        self.assertIs(NoExtra.__extra_items__, NoExtraItems)
+        self.assertEqual(NoExtra.__annotations__, {'a': str})
+        self.assertEqual(NoExtra.__required_keys__, frozenset({'a'}))
+        self.assertEqual(NoExtra.__optional_keys__, frozenset())
 
     def test_is_typeddict(self):
         self.assertIs(is_typeddict(Point2D), True)
@@ -4748,7 +4770,7 @@ class ExtraReadOnly(TypedDict):
         self.assertEqual(ExtraReadOnly.__optional_keys__, frozenset({}))
         self.assertEqual(ExtraReadOnly.__readonly_keys__, frozenset({'__extra_items__'}))
         self.assertEqual(ExtraReadOnly.__mutable_keys__, frozenset({}))
-        self.assertEqual(ExtraReadOnly.__extra_items__, None)
+        self.assertEqual(ExtraReadOnly.__extra_items__, NoExtraItems)
         self.assertFalse(ExtraReadOnly.__closed__)
 
         class ExtraRequired(TypedDict):
@@ -4758,7 +4780,7 @@ class ExtraRequired(TypedDict):
         self.assertEqual(ExtraRequired.__optional_keys__, frozenset({}))
         self.assertEqual(ExtraRequired.__readonly_keys__, frozenset({}))
         self.assertEqual(ExtraRequired.__mutable_keys__, frozenset({'__extra_items__'}))
-        self.assertEqual(ExtraRequired.__extra_items__, None)
+        self.assertEqual(ExtraRequired.__extra_items__, NoExtraItems)
         self.assertFalse(ExtraRequired.__closed__)
 
         class ExtraNotRequired(TypedDict):
@@ -4768,7 +4790,7 @@ class ExtraNotRequired(TypedDict):
         self.assertEqual(ExtraNotRequired.__optional_keys__, frozenset({'__extra_items__'}))
         self.assertEqual(ExtraNotRequired.__readonly_keys__, frozenset({}))
         self.assertEqual(ExtraNotRequired.__mutable_keys__, frozenset({'__extra_items__'}))
-        self.assertEqual(ExtraNotRequired.__extra_items__, None)
+        self.assertEqual(ExtraNotRequired.__extra_items__, NoExtraItems)
         self.assertFalse(ExtraNotRequired.__closed__)
 
     def test_closed_inheritance(self):
@@ -4810,7 +4832,7 @@ def test_implicit_extra_items(self):
         class Base(TypedDict):
             a: int
 
-        self.assertEqual(Base.__extra_items__, None)
+        self.assertEqual(Base.__extra_items__, NoExtraItems)
         self.assertFalse(Base.__closed__)
 
         class ChildA(Base, closed=True):

src/typing_extensions.py

@@ -95,6 +95,8 @@
     'ReadOnly',
     'Required',
     'NotRequired',
+    'NoDefault',
+    'NoExtraItems',
 
     # Pure aliases, have always been in typing
     'AbstractSet',
@@ -121,7 +123,6 @@
     'MutableMapping',
     'MutableSequence',
     'MutableSet',
-    'NoDefault',
     'Optional',
     'Pattern',
     'Reversible',
@@ -871,6 +872,59 @@ def inner(func):
     return inner
 
 
+if not hasattr(typing, "NoDefault") or not hasattr(typing, "NoExtraItems"):
+    class SingletonMeta(type):
+        def __setattr__(cls, attr, value):
+            # TypeError is consistent with the behavior of NoneType
+            raise TypeError(
+                f"cannot set {attr!r} attribute of immutable type {cls.__name__!r}"
+            )
+
+
+if hasattr(typing, "NoDefault"):
+    NoDefault = typing.NoDefault
+else:
+    class NoDefaultType(metaclass=SingletonMeta):
+        """The type of the NoDefault singleton."""
+
+        __slots__ = ()
+
+        def __new__(cls):
+            return globals().get("NoDefault") or object.__new__(cls)
+
+        def __repr__(self):
+            return "typing_extensions.NoDefault"
+
+        def __reduce__(self):
+            return "NoDefault"
+
+    NoDefault = NoDefaultType()
+    del NoDefaultType
+
+if hasattr(typing, "NoExtraItems"):
+    NoExtraItems = typing.NoExtraItems
+else:
+    class NoExtraItemsType(metaclass=SingletonMeta):
+        """The type of the NoExtraItems singleton."""
+
+        __slots__ = ()
+
+        def __new__(cls):
+            return globals().get("NoExtraItems") or object.__new__(cls)
+
+        def __repr__(self):
+            return "typing_extensions.NoExtraItems"
+
+        def __reduce__(self):
+            return "NoExtraItems"
+
+    NoExtraItems = NoExtraItemsType()
+    del NoExtraItemsType
+
+if not hasattr(typing, "NoDefault") or not hasattr(typing, "NoExtraItems"):
+    del SingletonMeta
+
+
 # Update this to something like >=3.13.0b1 if and when
 # PEP 728 is implemented in CPython
 _PEP_728_IMPLEMENTED = False
@@ -917,7 +971,7 @@ def _get_typeddict_qualifiers(annotation_type):
                 break
 
     class _TypedDictMeta(type):
-        def __new__(cls, name, bases, ns, *, total=True, closed=None, extra_items=None):
+        def __new__(cls, name, bases, ns, *, total=True, closed=None, extra_items=NoExtraItems):
             """Create new typed dict class object.
 
             This method is called when TypedDict is subclassed,
@@ -929,8 +983,8 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, extra_items=None):
                 if type(base) is not _TypedDictMeta and base is not typing.Generic:
                     raise TypeError('cannot inherit from both a TypedDict type '
                                     'and a non-TypedDict base class')
-            if closed is not None and extra_items is not None:
-                raise TypeError("Cannot combine closed=True and extra_items")
+            if closed is not None and extra_items is not NoExtraItems:
+                raise TypeError(f"Cannot combine closed={closed!r} and extra_items")
             elif closed is None:
                 closed = False
 
@@ -982,9 +1036,6 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, extra_items=None):
                 optional_keys.update(base_dict.get('__optional_keys__', ()))
                 readonly_keys.update(base_dict.get('__readonly_keys__', ()))
                 mutable_keys.update(base_dict.get('__mutable_keys__', ()))
-                base_extra_items_type = getattr(base, '__extra_items__', None)
-                if base_extra_items_type is not None:
-                    extra_items_type = base_extra_items_type
                 if getattr(base, "__closed__", False) and not closed:
                     if sys.version_info < (3, 14):
                         # PEP 728 wants this to be an error, but that is not
@@ -997,7 +1048,7 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, extra_items=None):
                     else:
                         raise TypeError("Child of a closed TypedDict must also be closed")
 
-            if closed and extra_items_type is None:
+            if closed and extra_items_type is NoExtraItems:
                 extra_items_type = Never
 
             # This was specified in an earlier version of PEP 728. Support
@@ -1059,7 +1110,16 @@ def __subclasscheck__(cls, other):
     _TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {})
 
     @_ensure_subclassable(lambda bases: (_TypedDict,))
-    def TypedDict(typename, fields=_marker, /, *, total=True, closed=False, **kwargs):
+    def TypedDict(
+        typename,
+        fields=_marker,
+        /,
+        *,
+        total=True,
+        closed=False,
+        extra_items=NoExtraItems,
+        **kwargs
+    ):
         """A simple typed namespace. At runtime it is equivalent to a plain dict.
 
         TypedDict creates a dictionary type such that a type checker will expect all
@@ -1119,9 +1179,14 @@ class Point2D(TypedDict):
                 "using the functional syntax, pass an empty dictionary, e.g. "
             ) + example + "."
             warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
+            # Support a field called "closed"
             if closed is not False and closed is not True:
                 kwargs["closed"] = closed
-                closed = False
+                closed = None
+            # Or "extra_items"
+            if extra_items is not NoExtraItems:
+                kwargs["extra_items"] = extra_items
+                extra_items = NoExtraItems
             fields = kwargs
         elif kwargs:
             raise TypeError("TypedDict takes either a dict or keyword arguments,"
@@ -1143,7 +1208,7 @@ class Point2D(TypedDict):
             # Setting correct module is necessary to make typed dict classes pickleable.
             ns['__module__'] = module
 
-        td = _TypedDictMeta(typename, (), ns, total=total, closed=closed)
+        td = _TypedDictMeta(typename, (), ns, total=total, closed=closed, extra_items=extra_items)
         td.__orig_bases__ = (TypedDict,)
         return td
 
@@ -1466,34 +1531,6 @@ def TypeAlias(self, parameters):
     )
 
 
-if hasattr(typing, "NoDefault"):
-    NoDefault = typing.NoDefault
-else:
-    class NoDefaultTypeMeta(type):
-        def __setattr__(cls, attr, value):
-            # TypeError is consistent with the behavior of NoneType
-            raise TypeError(
-                f"cannot set {attr!r} attribute of immutable type {cls.__name__!r}"
-            )
-
-    class NoDefaultType(metaclass=NoDefaultTypeMeta):
-        """The type of the NoDefault singleton."""
-
-        __slots__ = ()
-
-        def __new__(cls):
-            return globals().get("NoDefault") or object.__new__(cls)
-
-        def __repr__(self):
-            return "typing_extensions.NoDefault"
-
-        def __reduce__(self):
-            return "NoDefault"
-
-    NoDefault = NoDefaultType()
-    del NoDefaultType, NoDefaultTypeMeta
-
-
 def _set_default(type_param, default):
     type_param.has_default = lambda: default is not NoDefault
     type_param.__default__ = default