Pep 728 Assure if closed is not passed, the value of __closed__ is None. (#1)

Author: Daraan

src/test_typing_extensions.py

@@ -4060,16 +4060,19 @@ def test_typeddict_special_keyword_names(self):
         self.assertEqual(TD.__annotations__, {'cls': type, 'self': object, 'typename': str,
                                               '_typename': int, 'fields': list, '_fields': dict,
                                               'closed': bool, 'extra_items': bool})
-        self.assertIs(TD.__closed__, False)
+        self.assertIs(TD.__closed__, None)
         self.assertIs(TD.__extra_items__, NoExtraItems)
         a = TD(cls=str, self=42, typename='foo', _typename=53,
-               fields=[('bar', tuple)], _fields={'baz', set})
+               fields=[('bar', tuple)], _fields={'baz', set},
+               closed=None, extra_items="tea pot")
         self.assertEqual(a['cls'], str)
         self.assertEqual(a['self'], 42)
         self.assertEqual(a['typename'], 'foo')
         self.assertEqual(a['_typename'], 53)
         self.assertEqual(a['fields'], [('bar', tuple)])
         self.assertEqual(a['_fields'], {'baz', set})
+        self.assertEqual(a['closed'], None)
+        self.assertEqual(a['extra_items'], "tea pot")
 
     def test_typeddict_create_errors(self):
         with self.assertRaises(TypeError):
@@ -4317,6 +4320,16 @@ class ChildWithInlineAndOptional(Untotal, Inline):
                     class Wrong(*bases):
                         pass
 
+    def test_closed_values(self):
+        class Implicit(TypedDict): ...
+        class ExplicitTrue(TypedDict, closed=True): ...
+        class ExplicitFalse(TypedDict, closed=False): ...
+
+        self.assertIs(Implicit.__closed__, None)
+        self.assertIs(ExplicitTrue.__closed__, True)
+        self.assertIs(ExplicitFalse.__closed__, False)
+
+
     @skipIf(TYPING_3_14_0, "only supported on older versions")
     def test_closed_typeddict_compat(self):
         class Closed(TypedDict, closed=True):
@@ -4843,6 +4856,10 @@ class ChildA(Base, closed=True):
         self.assertEqual(ChildA.__extra_items__, Never)
         self.assertTrue(ChildA.__closed__)
 
+    @skipIf(TYPING_3_14_0, "Backwards compatibility only for Python 3.13")
+    def test_implicit_extra_items_before_3_14(self):
+        class Base(TypedDict):
+            a: int
         class ChildB(Base, closed=True):
             __extra_items__: None
 

src/typing_extensions.py

@@ -977,6 +977,7 @@ def _get_typeddict_qualifiers(annotation_type):
                 break
 
     class _TypedDictMeta(type):
+
         def __new__(cls, name, bases, ns, *, total=True, closed=None,
                     extra_items=NoExtraItems):
             """Create new typed dict class object.
@@ -992,8 +993,6 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None,
                                     'and a non-TypedDict base class')
             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
 
             if any(issubclass(b, typing.Generic) for b in bases):
                 generic_base = (typing.Generic,)
@@ -1043,7 +1042,7 @@ def __new__(cls, name, bases, ns, *, total=True, closed=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__', ()))
-                if getattr(base, "__closed__", False) and not closed:
+                if getattr(base, "__closed__", None) and not closed:
                     if sys.version_info < (3, 14):
                         # PEP 728 wants this to be an error, but that is not
                         # compatible with previous versions of typing-extensions.
@@ -1125,7 +1124,7 @@ def TypedDict(
         /,
         *,
         total=True,
-        closed=False,
+        closed=None,
         extra_items=NoExtraItems,
         **kwargs
     ):
@@ -1189,7 +1188,7 @@ class Point2D(TypedDict):
             ) + example + "."
             warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
             # Support a field called "closed"
-            if closed is not False and closed is not True:
+            if closed is not False and closed is not True and closed is not None:
                 kwargs["closed"] = closed
                 closed = None
             # Or "extra_items"