From 7cfb2c060563a24f3c1f444d125bd04f1b0976ad Mon Sep 17 00:00:00 2001 From: Victorien <65306057+Viicos@users.noreply.github.com> Date: Wed, 16 Apr 2025 22:25:21 +0200 Subject: [PATCH 1/4] Drop support for Python 3.8 (#585) --- .github/workflows/ci.yml | 2 - CHANGELOG.md | 4 + doc/index.rst | 2 +- pyproject.toml | 7 +- src/test_typing_extensions.py | 100 ++----- src/typing_extensions.py | 544 +++------------------------------- 6 files changed, 86 insertions(+), 573 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d0ced0b5..1f9d0650 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,7 +38,6 @@ jobs: # For available versions, see: # https://raw.githubusercontent.com/actions/python-versions/main/versions-manifest.json python-version: - - "3.8" - "3.9" - "3.9.12" - "3.10" @@ -49,7 +48,6 @@ jobs: - "3.12.0" - "3.13" - "3.13.0" - - "pypy3.8" - "pypy3.9" - "pypy3.10" diff --git a/CHANGELOG.md b/CHANGELOG.md index c2105ca9..560971ad 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,7 @@ +# Unreleased + +- Drop support for Python 3.8 (including PyPy-3.8). Patch by [Victorien Plot](https://github.com/Viicos). + # Release 4.13.2 (April 10, 2025) - Fix `TypeError` when taking the union of `typing_extensions.TypeAliasType` and a diff --git a/doc/index.rst b/doc/index.rst index 2c1a149c..e652c9e4 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -139,7 +139,7 @@ Example usage:: Python version support ---------------------- -``typing_extensions`` currently supports Python versions 3.8 and higher. In the future, +``typing_extensions`` currently supports Python versions 3.9 and higher. In the future, support for older Python versions will be dropped some time after that version reaches end of life. diff --git a/pyproject.toml b/pyproject.toml index b2f62fe6..48e2f914 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,9 +7,9 @@ build-backend = "flit_core.buildapi" [project] name = "typing_extensions" version = "4.13.2" -description = "Backported and Experimental Type Hints for Python 3.8+" +description = "Backported and Experimental Type Hints for Python 3.9+" readme = "README.md" -requires-python = ">=3.8" +requires-python = ">=3.9" license = "PSF-2.0" license-files = ["LICENSE"] keywords = [ @@ -34,7 +34,6 @@ classifiers = [ "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", @@ -63,7 +62,7 @@ exclude = [] [tool.ruff] line-length = 90 -target-version = "py38" +target-version = "py39" [tool.ruff.lint] select = [ diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index 584b0fa4..a6948951 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -110,7 +110,6 @@ # Flags used to mark tests that only apply after a specific # version of the typing module. -TYPING_3_9_0 = sys.version_info[:3] >= (3, 9, 0) TYPING_3_10_0 = sys.version_info[:3] >= (3, 10, 0) # 3.11 makes runtime type checks (_type_check) more lenient. @@ -1779,8 +1778,7 @@ class C(Generic[T]): pass self.assertIs(get_origin(List), list) self.assertIs(get_origin(Tuple), tuple) self.assertIs(get_origin(Callable), collections.abc.Callable) - if sys.version_info >= (3, 9): - self.assertIs(get_origin(list[int]), list) + self.assertIs(get_origin(list[int]), list) self.assertIs(get_origin(list), None) self.assertIs(get_origin(P.args), P) self.assertIs(get_origin(P.kwargs), P) @@ -1817,20 +1815,18 @@ class C(Generic[T]): pass self.assertEqual(get_args(List), ()) self.assertEqual(get_args(Tuple), ()) self.assertEqual(get_args(Callable), ()) - if sys.version_info >= (3, 9): - self.assertEqual(get_args(list[int]), (int,)) + self.assertEqual(get_args(list[int]), (int,)) self.assertEqual(get_args(list), ()) - if sys.version_info >= (3, 9): - # Support Python versions with and without the fix for - # https://bugs.python.org/issue42195 - # The first variant is for 3.9.2+, the second for 3.9.0 and 1 - self.assertIn(get_args(collections.abc.Callable[[int], str]), - (([int], str), ([[int]], str))) - self.assertIn(get_args(collections.abc.Callable[[], str]), - (([], str), ([[]], str))) - self.assertEqual(get_args(collections.abc.Callable[..., str]), (..., str)) + # Support Python versions with and without the fix for + # https://bugs.python.org/issue42195 + # The first variant is for 3.9.2+, the second for 3.9.0 and 1 + self.assertIn(get_args(collections.abc.Callable[[int], str]), + (([int], str), ([[int]], str))) + self.assertIn(get_args(collections.abc.Callable[[], str]), + (([], str), ([[]], str))) + self.assertEqual(get_args(collections.abc.Callable[..., str]), (..., str)) P = ParamSpec('P') - # In 3.9 and lower we use typing_extensions's hacky implementation + # In 3.9 we use typing_extensions's hacky implementation # of ParamSpec, which gets incorrectly wrapped in a list self.assertIn(get_args(Callable[P, int]), [(P, int), ([P], int)]) self.assertEqual(get_args(Required[int]), (int,)) @@ -3808,7 +3804,7 @@ def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ... MemoizedFunc[[int, str, str]] if sys.version_info >= (3, 10): - # These unfortunately don't pass on <=3.9, + # These unfortunately don't pass on 3.9, # due to typing._type_check on older Python versions X = MemoizedFunc[[int, str, str], T, T2] self.assertEqual(X.__parameters__, (T, T2)) @@ -4553,7 +4549,7 @@ class PointDict3D(PointDict2D, total=False): assert is_typeddict(PointDict2D) is True assert is_typeddict(PointDict3D) is True - @skipUnless(HAS_FORWARD_MODULE, "ForwardRef.__forward_module__ was added in 3.9") + @skipUnless(HAS_FORWARD_MODULE, "ForwardRef.__forward_module__ was added in 3.9.7") def test_get_type_hints_cross_module_subclass(self): self.assertNotIn("_DoNotImport", globals()) self.assertEqual( @@ -4696,11 +4692,9 @@ class WithImplicitAny(B): with self.assertRaises(TypeError): WithImplicitAny[str] - @skipUnless(TYPING_3_9_0, "Was changed in 3.9") def test_non_generic_subscript(self): # For backward compatibility, subscription works # on arbitrary TypedDict types. - # (But we don't attempt to backport this misfeature onto 3.8.) class TD(TypedDict): a: T A = TD[int] @@ -5163,7 +5157,7 @@ class C: A.x = 5 self.assertEqual(C.x, 5) - @skipIf(sys.version_info[:2] in ((3, 9), (3, 10)), "Waiting for bpo-46491 bugfix.") + @skipIf(sys.version_info[:2] == (3, 10), "Waiting for https://github.com/python/cpython/issues/90649 bugfix.") def test_special_form_containment(self): class C: classvar: Annotated[ClassVar[int], "a decoration"] = 4 @@ -5475,21 +5469,20 @@ def test_valid_uses(self): self.assertEqual(C2.__parameters__, (P, T)) # Test collections.abc.Callable too. - if sys.version_info[:2] >= (3, 9): - # Note: no tests for Callable.__parameters__ here - # because types.GenericAlias Callable is hardcoded to search - # for tp_name "TypeVar" in C. This was changed in 3.10. - C3 = collections.abc.Callable[P, int] - self.assertEqual(C3.__args__, (P, int)) - C4 = collections.abc.Callable[P, T] - self.assertEqual(C4.__args__, (P, T)) + # Note: no tests for Callable.__parameters__ here + # because types.GenericAlias Callable is hardcoded to search + # for tp_name "TypeVar" in C. This was changed in 3.10. + C3 = collections.abc.Callable[P, int] + self.assertEqual(C3.__args__, (P, int)) + C4 = collections.abc.Callable[P, T] + self.assertEqual(C4.__args__, (P, T)) # ParamSpec instances should also have args and kwargs attributes. # Note: not in dir(P) because of __class__ hacks self.assertTrue(hasattr(P, 'args')) self.assertTrue(hasattr(P, 'kwargs')) - @skipIf((3, 10, 0) <= sys.version_info[:3] <= (3, 10, 2), "Needs bpo-46676.") + @skipIf((3, 10, 0) <= sys.version_info[:3] <= (3, 10, 2), "Needs https://github.com/python/cpython/issues/90834.") def test_args_kwargs(self): P = ParamSpec('P') P_2 = ParamSpec('P_2') @@ -5649,8 +5642,6 @@ class ProtoZ(Protocol[P]): G10 = klass[int, Concatenate[str, P]] with self.subTest("Check invalid form substitution"): self.assertEqual(G10.__parameters__, (P, )) - if sys.version_info < (3, 9): - self.skipTest("3.8 typing._type_subst does not support this substitution process") H10 = G10[int] if (3, 10) <= sys.version_info < (3, 11, 3): self.skipTest("3.10-3.11.2 does not substitute Concatenate here") @@ -5780,9 +5771,6 @@ def test_valid_uses(self): T = TypeVar('T') for callable_variant in (Callable, collections.abc.Callable): with self.subTest(callable_variant=callable_variant): - if not TYPING_3_9_0 and callable_variant is collections.abc.Callable: - self.skipTest("Needs PEP 585") - C1 = callable_variant[Concatenate[int, P], int] C2 = callable_variant[Concatenate[int, T, P], T] self.assertEqual(C1.__origin__, C2.__origin__) @@ -5830,7 +5818,7 @@ def test_invalid_uses(self): ): Concatenate[(str,), P] - @skipUnless(TYPING_3_10_0, "Missing backport to <=3.9. See issue #48") + @skipUnless(TYPING_3_10_0, "Missing backport to 3.9. See issue #48") def test_alias_subscription_with_ellipsis(self): P = ParamSpec('P') X = Callable[Concatenate[int, P], Any] @@ -6813,7 +6801,6 @@ class Y(Generic[T], NamedTuple): with self.assertRaisesRegex(TypeError, f'Too many {things}'): G[int, str] - @skipUnless(TYPING_3_9_0, "tuple.__class_getitem__ was added in 3.9") def test_non_generic_subscript_py39_plus(self): # For backward compatibility, subscription works # on arbitrary NamedTuple types. @@ -6828,19 +6815,6 @@ class Group(NamedTuple): self.assertIs(type(a), Group) self.assertEqual(a, (1, [2])) - @skipIf(TYPING_3_9_0, "Test isn't relevant to 3.9+") - def test_non_generic_subscript_error_message_py38(self): - class Group(NamedTuple): - key: T - group: List[T] - - with self.assertRaisesRegex(TypeError, 'not subscriptable'): - Group[int] - - for attr in ('__args__', '__origin__', '__parameters__'): - with self.subTest(attr=attr): - self.assertFalse(hasattr(Group, attr)) - def test_namedtuple_keyword_usage(self): with self.assertWarnsRegex( DeprecationWarning, @@ -6959,21 +6933,13 @@ def test_copy_and_pickle(self): def test_docstring(self): self.assertIsInstance(NamedTuple.__doc__, str) - @skipUnless(TYPING_3_9_0, "NamedTuple was a class on 3.8 and lower") - def test_same_as_typing_NamedTuple_39_plus(self): + def test_same_as_typing_NamedTuple(self): self.assertEqual( set(dir(NamedTuple)) - {"__text_signature__"}, set(dir(typing.NamedTuple)) ) self.assertIs(type(NamedTuple), type(typing.NamedTuple)) - @skipIf(TYPING_3_9_0, "tests are only relevant to <=3.8") - def test_same_as_typing_NamedTuple_38_minus(self): - self.assertEqual( - self.NestedEmployee.__annotations__, - self.NestedEmployee._field_types - ) - def test_orig_bases(self): T = TypeVar('T') @@ -7235,11 +7201,8 @@ def test_bound_errors(self): r"Bound must be a type\. Got \(1, 2\)\."): TypeVar('X', bound=(1, 2)) - # Technically we could run it on later versions of 3.8, - # but that's not worth the effort. - @skipUnless(TYPING_3_9_0, "Fix was not backported") def test_missing__name__(self): - # See bpo-39942 + # See https://github.com/python/cpython/issues/84123 code = ("import typing\n" "T = typing.TypeVar('T')\n" ) @@ -7420,9 +7383,8 @@ def test_allow_default_after_non_default_in_alias(self): a1 = Callable[[T_default], T] self.assertEqual(a1.__args__, (T_default, T)) - if sys.version_info >= (3, 9): - a2 = dict[T_default, T] - self.assertEqual(a2.__args__, (T_default, T)) + a2 = dict[T_default, T] + self.assertEqual(a2.__args__, (T_default, T)) a3 = typing.Dict[T_default, T] self.assertEqual(a3.__args__, (T_default, T)) @@ -7602,7 +7564,6 @@ class D(B[str], float): pass with self.assertRaisesRegex(TypeError, "Expected an instance of type"): get_original_bases(object()) - @skipUnless(TYPING_3_9_0, "PEP 585 is yet to be") def test_builtin_generics(self): class E(list[T]): pass class F(list[int]): pass @@ -8848,7 +8809,6 @@ def test_fwdref_value_is_cached(self): self.assertIs(evaluate_forward_ref(fr, globals={"hello": str}), str) self.assertIs(evaluate_forward_ref(fr), str) - @skipUnless(TYPING_3_9_0, "Needs PEP 585 support") def test_fwdref_with_owner(self): self.assertEqual( evaluate_forward_ref(typing.ForwardRef("Counter[int]"), owner=collections), @@ -8894,16 +8854,14 @@ class Y(Generic[Tx]): with self.subTest("nested string of TypeVar"): evaluated_ref2 = evaluate_forward_ref(typing.ForwardRef("""Y["Y['Tx']"]"""), locals={"Y": Y}) self.assertEqual(get_origin(evaluated_ref2), Y) - if not TYPING_3_9_0: - self.skipTest("Nested string 'Tx' stays ForwardRef in 3.8") self.assertEqual(get_args(evaluated_ref2), (Y[Tx],)) with self.subTest("nested string of TypeAliasType and alias"): # NOTE: Using Y here works for 3.10 evaluated_ref3 = evaluate_forward_ref(typing.ForwardRef("""Y['Z["StrAlias"]']"""), locals={"Y": Y, "Z": Z, "StrAlias": str}) self.assertEqual(get_origin(evaluated_ref3), Y) - if sys.version_info[:2] in ((3,8), (3, 10)): - self.skipTest("Nested string 'StrAlias' is not resolved in 3.8 and 3.10") + if sys.version_info[:2] == (3, 10): + self.skipTest("Nested string 'StrAlias' is not resolved in 3.10") self.assertEqual(get_args(evaluated_ref3), (Z[str],)) def test_invalid_special_forms(self): diff --git a/src/typing_extensions.py b/src/typing_extensions.py index fa89c83e..f8b2f76e 100644 --- a/src/typing_extensions.py +++ b/src/typing_extensions.py @@ -166,12 +166,9 @@ def _should_collect_from_parameters(t): return isinstance( t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType) ) -elif sys.version_info >= (3, 9): - def _should_collect_from_parameters(t): - return isinstance(t, (typing._GenericAlias, _types.GenericAlias)) else: def _should_collect_from_parameters(t): - return isinstance(t, typing._GenericAlias) and not t._special + return isinstance(t, (typing._GenericAlias, _types.GenericAlias)) NoReturn = typing.NoReturn @@ -434,28 +431,14 @@ def clear_overloads(): def _is_dunder(attr): return attr.startswith('__') and attr.endswith('__') - # Python <3.9 doesn't have typing._SpecialGenericAlias - _special_generic_alias_base = getattr( - typing, "_SpecialGenericAlias", typing._GenericAlias - ) - class _SpecialGenericAlias(_special_generic_alias_base, _root=True): + class _SpecialGenericAlias(typing._SpecialGenericAlias, _root=True): def __init__(self, origin, nparams, *, inst=True, name=None, defaults=()): - if _special_generic_alias_base is typing._GenericAlias: - # Python <3.9 - self.__origin__ = origin - self._nparams = nparams - super().__init__(origin, nparams, special=True, inst=inst, name=name) - else: - # Python >= 3.9 - super().__init__(origin, nparams, inst=inst, name=name) + super().__init__(origin, nparams, inst=inst, name=name) self._defaults = defaults def __setattr__(self, attr, val): allowed_attrs = {'_name', '_inst', '_nparams', '_defaults'} - if _special_generic_alias_base is typing._GenericAlias: - # Python <3.9 - allowed_attrs.add("__origin__") if _is_dunder(attr) or attr in allowed_attrs: object.__setattr__(self, attr, val) else: @@ -585,7 +568,7 @@ class _ProtocolMeta(type(typing.Protocol)): # but is necessary for several reasons... # # NOTE: DO NOT call super() in any methods in this class - # That would call the methods on typing._ProtocolMeta on Python 3.8-3.11 + # That would call the methods on typing._ProtocolMeta on Python <=3.11 # and those are slow def __new__(mcls, name, bases, namespace, **kwargs): if name == "Protocol" and len(bases) < 2: @@ -786,7 +769,7 @@ def close(self): ... runtime = runtime_checkable -# Our version of runtime-checkable protocols is faster on Python 3.8-3.11 +# Our version of runtime-checkable protocols is faster on Python <=3.11 if sys.version_info >= (3, 12): SupportsInt = typing.SupportsInt SupportsFloat = typing.SupportsFloat @@ -864,17 +847,9 @@ def __round__(self, ndigits: int = 0) -> T_co: def _ensure_subclassable(mro_entries): - def inner(func): - if sys.implementation.name == "pypy" and sys.version_info < (3, 9): - cls_dict = { - "__call__": staticmethod(func), - "__mro_entries__": staticmethod(mro_entries) - } - t = type(func.__name__, (), cls_dict) - return functools.update_wrapper(t(), func) - else: - func.__mro_entries__ = mro_entries - return func + def inner(obj): + obj.__mro_entries__ = mro_entries + return obj return inner @@ -940,8 +915,6 @@ def __reduce__(self): _PEP_728_IMPLEMENTED = False if _PEP_728_IMPLEMENTED: - # The standard library TypedDict in Python 3.8 does not store runtime information - # about which (if any) keys are optional. See https://bugs.python.org/issue38834 # The standard library TypedDict in Python 3.9.0/1 does not honour the "total" # keyword with old-style TypedDict(). See https://bugs.python.org/issue42059 # The standard library TypedDict below Python 3.11 does not store runtime @@ -1209,10 +1182,7 @@ class Point2D(TypedDict): td.__orig_bases__ = (TypedDict,) return td - if hasattr(typing, "_TypedDictMeta"): - _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta) - else: - _TYPEDDICT_TYPES = (_TypedDictMeta,) + _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta) def is_typeddict(tp): """Check if an annotation is a TypedDict class @@ -1225,9 +1195,6 @@ class Film(TypedDict): is_typeddict(Film) # => True is_typeddict(Union[list, str]) # => False """ - # On 3.8, this would otherwise return True - if hasattr(typing, "TypedDict") and tp is typing.TypedDict: - return False return isinstance(tp, _TYPEDDICT_TYPES) @@ -1257,7 +1224,7 @@ def greet(name: str) -> None: # replaces _strip_annotations() def _strip_extras(t): """Strips Annotated, Required and NotRequired from a given type.""" - if isinstance(t, _AnnotatedAlias): + if isinstance(t, typing._AnnotatedAlias): return _strip_extras(t.__origin__) if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired, ReadOnly): return _strip_extras(t.__args__[0]) @@ -1311,23 +1278,11 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False): - If two dict arguments are passed, they specify globals and locals, respectively. """ - if hasattr(typing, "Annotated"): # 3.9+ - hint = typing.get_type_hints( - obj, globalns=globalns, localns=localns, include_extras=True - ) - else: # 3.8 - hint = typing.get_type_hints(obj, globalns=globalns, localns=localns) + hint = typing.get_type_hints( + obj, globalns=globalns, localns=localns, include_extras=True + ) if sys.version_info < (3, 11): _clean_optional(obj, hint, globalns, localns) - if sys.version_info < (3, 9): - # In 3.8 eval_type does not flatten Optional[ForwardRef] correctly - # This will recreate and and cache Unions. - hint = { - k: (t - if get_origin(t) != Union - else Union[t.__args__]) - for k, t in hint.items() - } if include_extras: return hint return {k: _strip_extras(t) for k, t in hint.items()} @@ -1336,8 +1291,7 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False): def _could_be_inserted_optional(t): """detects Union[..., None] pattern""" - # 3.8+ compatible checking before _UnionGenericAlias - if get_origin(t) is not Union: + if not isinstance(t, typing._UnionGenericAlias): return False # Assume if last argument is not None they are user defined if t.__args__[-1] is not _NoneType: @@ -1381,17 +1335,12 @@ def _clean_optional(obj, hints, globalns=None, localns=None): localns = globalns elif localns is None: localns = globalns - if sys.version_info < (3, 9): - original_value = ForwardRef(original_value) - else: - original_value = ForwardRef( - original_value, - is_argument=not isinstance(obj, _types.ModuleType) - ) + + original_value = ForwardRef( + original_value, + is_argument=not isinstance(obj, _types.ModuleType) + ) original_evaluated = typing._eval_type(original_value, globalns, localns) - if sys.version_info < (3, 9) and get_origin(original_evaluated) is Union: - # Union[str, None, "str"] is not reduced to Union[str, None] - original_evaluated = Union[original_evaluated.__args__] # Compare if values differ. Note that even if equal # value might be cached by typing._tp_cache contrary to original_evaluated if original_evaluated != value or ( @@ -1402,130 +1351,13 @@ def _clean_optional(obj, hints, globalns=None, localns=None): ): hints[name] = original_evaluated -# Python 3.9+ has PEP 593 (Annotated) -if hasattr(typing, 'Annotated'): - Annotated = typing.Annotated - # Not exported and not a public API, but needed for get_origin() and get_args() - # to work. - _AnnotatedAlias = typing._AnnotatedAlias -# 3.8 -else: - class _AnnotatedAlias(typing._GenericAlias, _root=True): - """Runtime representation of an annotated type. - - At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't' - with extra annotations. The alias behaves like a normal typing alias, - instantiating is the same as instantiating the underlying type, binding - it to types is also the same. - """ - def __init__(self, origin, metadata): - if isinstance(origin, _AnnotatedAlias): - metadata = origin.__metadata__ + metadata - origin = origin.__origin__ - super().__init__(origin, origin) - self.__metadata__ = metadata - - def copy_with(self, params): - assert len(params) == 1 - new_type = params[0] - return _AnnotatedAlias(new_type, self.__metadata__) - - def __repr__(self): - return (f"typing_extensions.Annotated[{typing._type_repr(self.__origin__)}, " - f"{', '.join(repr(a) for a in self.__metadata__)}]") - - def __reduce__(self): - return operator.getitem, ( - Annotated, (self.__origin__, *self.__metadata__) - ) - - def __eq__(self, other): - if not isinstance(other, _AnnotatedAlias): - return NotImplemented - if self.__origin__ != other.__origin__: - return False - return self.__metadata__ == other.__metadata__ - - def __hash__(self): - return hash((self.__origin__, self.__metadata__)) - - class Annotated: - """Add context specific metadata to a type. - - Example: Annotated[int, runtime_check.Unsigned] indicates to the - hypothetical runtime_check module that this type is an unsigned int. - Every other consumer of this type can ignore this metadata and treat - this type as int. - - The first argument to Annotated must be a valid type (and will be in - the __origin__ field), the remaining arguments are kept as a tuple in - the __extra__ field. - - Details: - - - It's an error to call `Annotated` with less than two arguments. - - Nested Annotated are flattened:: - - Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3] - - - Instantiating an annotated type is equivalent to instantiating the - underlying type:: - - Annotated[C, Ann1](5) == C(5) - - - Annotated can be used as a generic type alias:: - - Optimized = Annotated[T, runtime.Optimize()] - Optimized[int] == Annotated[int, runtime.Optimize()] - - OptimizedList = Annotated[List[T], runtime.Optimize()] - OptimizedList[int] == Annotated[List[int], runtime.Optimize()] - """ - - __slots__ = () - - def __new__(cls, *args, **kwargs): - raise TypeError("Type Annotated cannot be instantiated.") - - @typing._tp_cache - def __class_getitem__(cls, params): - if not isinstance(params, tuple) or len(params) < 2: - raise TypeError("Annotated[...] should be used " - "with at least two arguments (a type and an " - "annotation).") - allowed_special_forms = (ClassVar, Final) - if get_origin(params[0]) in allowed_special_forms: - origin = params[0] - else: - msg = "Annotated[t, ...]: t must be a type." - origin = typing._type_check(params[0], msg) - metadata = tuple(params[1:]) - return _AnnotatedAlias(origin, metadata) - - def __init_subclass__(cls, *args, **kwargs): - raise TypeError( - f"Cannot subclass {cls.__module__}.Annotated" - ) - -# Python 3.8 has get_origin() and get_args() but those implementations aren't -# Annotated-aware, so we can't use those. Python 3.9's versions don't support +# Python 3.9 has get_origin() and get_args() but those implementations don't support # ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do. if sys.version_info[:2] >= (3, 10): get_origin = typing.get_origin get_args = typing.get_args -# 3.8-3.9 +# 3.9 else: - try: - # 3.9+ - from typing import _BaseGenericAlias - except ImportError: - _BaseGenericAlias = typing._GenericAlias - try: - # 3.9+ - from typing import GenericAlias as _typing_GenericAlias - except ImportError: - _typing_GenericAlias = typing._GenericAlias - def get_origin(tp): """Get the unsubscripted version of a type. @@ -1541,9 +1373,9 @@ def get_origin(tp): get_origin(List[Tuple[T, T]][int]) == list get_origin(P.args) is P """ - if isinstance(tp, _AnnotatedAlias): + if isinstance(tp, typing._AnnotatedAlias): return Annotated - if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias, _BaseGenericAlias, + if isinstance(tp, (typing._BaseGenericAlias, _types.GenericAlias, ParamSpecArgs, ParamSpecKwargs)): return tp.__origin__ if tp is typing.Generic: @@ -1561,11 +1393,9 @@ def get_args(tp): get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int]) get_args(Callable[[], T][int]) == ([], int) """ - if isinstance(tp, _AnnotatedAlias): + if isinstance(tp, typing._AnnotatedAlias): return (tp.__origin__, *tp.__metadata__) - if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias)): - if getattr(tp, "_special", False): - return () + if isinstance(tp, (typing._GenericAlias, _types.GenericAlias)): res = tp.__args__ if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis: res = (list(res[:-1]), res[-1]) @@ -1577,7 +1407,7 @@ def get_args(tp): if hasattr(typing, 'TypeAlias'): TypeAlias = typing.TypeAlias # 3.9 -elif sys.version_info[:2] >= (3, 9): +else: @_ExtensionsSpecialForm def TypeAlias(self, parameters): """Special marker indicating that an assignment should @@ -1591,21 +1421,6 @@ def TypeAlias(self, parameters): It's invalid when used anywhere except as in the example above. """ raise TypeError(f"{self} is not subscriptable") -# 3.8 -else: - TypeAlias = _ExtensionsSpecialForm( - 'TypeAlias', - doc="""Special marker indicating that an assignment should - be recognized as a proper type alias definition by type - checkers. - - For example:: - - Predicate: TypeAlias = Callable[..., bool] - - It's invalid when used anywhere except as in the example - above.""" - ) def _set_default(type_param, default): @@ -1679,7 +1494,7 @@ def __init_subclass__(cls) -> None: if hasattr(typing, 'ParamSpecArgs'): ParamSpecArgs = typing.ParamSpecArgs ParamSpecKwargs = typing.ParamSpecKwargs -# 3.8-3.9 +# 3.9 else: class _Immutable: """Mixin to indicate that object should not be copied.""" @@ -1790,7 +1605,7 @@ def _paramspec_prepare_subst(alias, args): def __init_subclass__(cls) -> None: raise TypeError(f"type '{__name__}.ParamSpec' is not an acceptable base type") -# 3.8-3.9 +# 3.9 else: # Inherits from list as a workaround for Callable checks in Python < 3.9.2. @@ -1895,7 +1710,7 @@ def __call__(self, *args, **kwargs): pass -# 3.8-3.9 +# 3.9 if not hasattr(typing, 'Concatenate'): # Inherits from list as a workaround for Callable checks in Python < 3.9.2. @@ -1920,9 +1735,6 @@ class _ConcatenateGenericAlias(list): # Trick Generic into looking into this for __parameters__. __class__ = typing._GenericAlias - # Flag in 3.8. - _special = False - def __init__(self, origin, args): super().__init__(args) self.__origin__ = origin @@ -1946,7 +1758,6 @@ def __parameters__(self): tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec)) ) - # 3.8; needed for typing._subst_tvars # 3.9 used by __getitem__ below def copy_with(self, params): if isinstance(params[-1], _ConcatenateGenericAlias): @@ -1974,7 +1785,7 @@ def __getitem__(self, args): prepare = getattr(param, "__typing_prepare_subst__", None) if prepare is not None: args = prepare(self, args) - # 3.8 - 3.9 & typing.ParamSpec + # 3.9 & typing.ParamSpec elif isinstance(param, ParamSpec): i = params.index(param) if ( @@ -1990,7 +1801,7 @@ def __getitem__(self, args): args = (args,) elif ( isinstance(args[i], list) - # 3.8 - 3.9 + # 3.9 # This class inherits from list do not convert and not isinstance(args[i], _ConcatenateGenericAlias) ): @@ -2063,11 +1874,11 @@ def __getitem__(self, args): return value -# 3.8-3.9.2 +# 3.9.2 class _EllipsisDummy: ... -# 3.8-3.10 +# <=3.10 def _create_concatenate_alias(origin, parameters): if parameters[-1] is ... and sys.version_info < (3, 9, 2): # Hack: Arguments must be types, replace it with one. @@ -2091,7 +1902,7 @@ def _create_concatenate_alias(origin, parameters): return concatenate -# 3.8-3.10 +# <=3.10 @typing._tp_cache def _concatenate_getitem(self, parameters): if parameters == (): @@ -2110,8 +1921,8 @@ def _concatenate_getitem(self, parameters): # 3.11+; Concatenate does not accept ellipsis in 3.10 if sys.version_info >= (3, 11): Concatenate = typing.Concatenate -# 3.9-3.10 -elif sys.version_info[:2] >= (3, 9): +# <=3.10 +else: @_ExtensionsSpecialForm def Concatenate(self, parameters): """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a @@ -2125,30 +1936,13 @@ def Concatenate(self, parameters): See PEP 612 for detailed information. """ return _concatenate_getitem(self, parameters) -# 3.8 -else: - class _ConcatenateForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - return _concatenate_getitem(self, parameters) - - Concatenate = _ConcatenateForm( - 'Concatenate', - doc="""Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a - higher order function which adds, removes or transforms parameters of a - callable. - - For example:: - - Callable[Concatenate[int, P], int] - See PEP 612 for detailed information. - """) # 3.10+ if hasattr(typing, 'TypeGuard'): TypeGuard = typing.TypeGuard # 3.9 -elif sys.version_info[:2] >= (3, 9): +else: @_ExtensionsSpecialForm def TypeGuard(self, parameters): """Special typing form used to annotate the return type of a user-defined @@ -2195,64 +1989,13 @@ def is_str(val: Union[str, float]): """ item = typing._type_check(parameters, f'{self} accepts only a single type.') return typing._GenericAlias(self, (item,)) -# 3.8 -else: - class _TypeGuardForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - item = typing._type_check(parameters, - f'{self._name} accepts only a single type') - return typing._GenericAlias(self, (item,)) - TypeGuard = _TypeGuardForm( - 'TypeGuard', - doc="""Special typing form used to annotate the return type of a user-defined - type guard function. ``TypeGuard`` only accepts a single type argument. - At runtime, functions marked this way should return a boolean. - - ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static - type checkers to determine a more precise type of an expression within a - program's code flow. Usually type narrowing is done by analyzing - conditional code flow and applying the narrowing to a block of code. The - conditional expression here is sometimes referred to as a "type guard". - - Sometimes it would be convenient to use a user-defined boolean function - as a type guard. Such a function should use ``TypeGuard[...]`` as its - return type to alert static type checkers to this intention. - - Using ``-> TypeGuard`` tells the static type checker that for a given - function: - - 1. The return value is a boolean. - 2. If the return value is ``True``, the type of its argument - is the type inside ``TypeGuard``. - - For example:: - - def is_str(val: Union[str, float]): - # "isinstance" type guard - if isinstance(val, str): - # Type of ``val`` is narrowed to ``str`` - ... - else: - # Else, type of ``val`` is narrowed to ``float``. - ... - - Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower - form of ``TypeA`` (it can even be a wider form) and this may lead to - type-unsafe results. The main reason is to allow for things like - narrowing ``List[object]`` to ``List[str]`` even though the latter is not - a subtype of the former, since ``List`` is invariant. The responsibility of - writing type-safe type guards is left to the user. - - ``TypeGuard`` also works with type variables. For more information, see - PEP 647 (User-Defined Type Guards). - """) # 3.13+ if hasattr(typing, 'TypeIs'): TypeIs = typing.TypeIs -# 3.9 -elif sys.version_info[:2] >= (3, 9): +# <=3.12 +else: @_ExtensionsSpecialForm def TypeIs(self, parameters): """Special typing form used to annotate the return type of a user-defined @@ -2293,58 +2036,13 @@ def f(val: Union[int, Awaitable[int]]) -> int: """ item = typing._type_check(parameters, f'{self} accepts only a single type.') return typing._GenericAlias(self, (item,)) -# 3.8 -else: - class _TypeIsForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - item = typing._type_check(parameters, - f'{self._name} accepts only a single type') - return typing._GenericAlias(self, (item,)) - TypeIs = _TypeIsForm( - 'TypeIs', - doc="""Special typing form used to annotate the return type of a user-defined - type narrower function. ``TypeIs`` only accepts a single type argument. - At runtime, functions marked this way should return a boolean. - - ``TypeIs`` aims to benefit *type narrowing* -- a technique used by static - type checkers to determine a more precise type of an expression within a - program's code flow. Usually type narrowing is done by analyzing - conditional code flow and applying the narrowing to a block of code. The - conditional expression here is sometimes referred to as a "type guard". - - Sometimes it would be convenient to use a user-defined boolean function - as a type guard. Such a function should use ``TypeIs[...]`` as its - return type to alert static type checkers to this intention. - - Using ``-> TypeIs`` tells the static type checker that for a given - function: - - 1. The return value is a boolean. - 2. If the return value is ``True``, the type of its argument - is the intersection of the type inside ``TypeIs`` and the argument's - previously known type. - - For example:: - - def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]: - return hasattr(val, '__await__') - - def f(val: Union[int, Awaitable[int]]) -> int: - if is_awaitable(val): - assert_type(val, Awaitable[int]) - else: - assert_type(val, int) - - ``TypeIs`` also works with type variables. For more information, see - PEP 742 (Narrowing types with TypeIs). - """) # 3.14+? if hasattr(typing, 'TypeForm'): TypeForm = typing.TypeForm -# 3.9 -elif sys.version_info[:2] >= (3, 9): +# <=3.13 +else: class _TypeFormForm(_ExtensionsSpecialForm, _root=True): # TypeForm(X) is equivalent to X but indicates to the type checker # that the object is a TypeForm. @@ -2372,36 +2070,6 @@ def cast[T](typ: TypeForm[T], value: Any) -> T: ... """ item = typing._type_check(parameters, f'{self} accepts only a single type.') return typing._GenericAlias(self, (item,)) -# 3.8 -else: - class _TypeFormForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - item = typing._type_check(parameters, - f'{self._name} accepts only a single type') - return typing._GenericAlias(self, (item,)) - - def __call__(self, obj, /): - return obj - - TypeForm = _TypeFormForm( - 'TypeForm', - doc="""A special form representing the value that results from the evaluation - of a type expression. This value encodes the information supplied in the - type expression, and it represents the type described by that type expression. - - When used in a type expression, TypeForm describes a set of type form objects. - It accepts a single type argument, which must be a valid type expression. - ``TypeForm[T]`` describes the set of all type form objects that represent - the type T or types that are assignable to T. - - Usage: - - def cast[T](typ: TypeForm[T], value: Any) -> T: ... - - reveal_type(cast(int, "x")) # int - - See PEP 747 for more information. - """) # Vendored from cpython typing._SpecialFrom @@ -2525,7 +2193,7 @@ def int_or_str(arg: int | str) -> None: if hasattr(typing, 'Required'): # 3.11+ Required = typing.Required NotRequired = typing.NotRequired -elif sys.version_info[:2] >= (3, 9): # 3.9-3.10 +else: # <=3.10 @_ExtensionsSpecialForm def Required(self, parameters): """A special typing construct to mark a key of a total=False TypedDict @@ -2563,49 +2231,10 @@ class Movie(TypedDict): item = typing._type_check(parameters, f'{self._name} accepts only a single type.') return typing._GenericAlias(self, (item,)) -else: # 3.8 - class _RequiredForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - item = typing._type_check(parameters, - f'{self._name} accepts only a single type.') - return typing._GenericAlias(self, (item,)) - - Required = _RequiredForm( - 'Required', - doc="""A special typing construct to mark a key of a total=False TypedDict - as required. For example: - - class Movie(TypedDict, total=False): - title: Required[str] - year: int - - m = Movie( - title='The Matrix', # typechecker error if key is omitted - year=1999, - ) - - There is no runtime checking that a required key is actually provided - when instantiating a related TypedDict. - """) - NotRequired = _RequiredForm( - 'NotRequired', - doc="""A special typing construct to mark a key of a TypedDict as - potentially missing. For example: - - class Movie(TypedDict): - title: str - year: NotRequired[int] - - m = Movie( - title='The Matrix', # typechecker error if key is omitted - year=1999, - ) - """) - if hasattr(typing, 'ReadOnly'): ReadOnly = typing.ReadOnly -elif sys.version_info[:2] >= (3, 9): # 3.9-3.12 +else: # <=3.12 @_ExtensionsSpecialForm def ReadOnly(self, parameters): """A special typing construct to mark an item of a TypedDict as read-only. @@ -2625,30 +2254,6 @@ def mutate_movie(m: Movie) -> None: item = typing._type_check(parameters, f'{self._name} accepts only a single type.') return typing._GenericAlias(self, (item,)) -else: # 3.8 - class _ReadOnlyForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - item = typing._type_check(parameters, - f'{self._name} accepts only a single type.') - return typing._GenericAlias(self, (item,)) - - ReadOnly = _ReadOnlyForm( - 'ReadOnly', - doc="""A special typing construct to mark a key of a TypedDict as read-only. - - For example: - - class Movie(TypedDict): - title: ReadOnly[str] - year: int - - def mutate_movie(m: Movie) -> None: - m["year"] = 1992 # allowed - m["title"] = "The Matrix" # typechecker error - - There is no runtime checking for this propery. - """) - _UNPACK_DOC = """\ Type unpack operator. @@ -2698,7 +2303,7 @@ def foo(**kwargs: Unpack[Movie]): ... def _is_unpack(obj): return get_origin(obj) is Unpack -elif sys.version_info[:2] >= (3, 9): # 3.9+ +else: # <=3.11 class _UnpackSpecialForm(_ExtensionsSpecialForm, _root=True): def __init__(self, getitem): super().__init__(getitem) @@ -2739,43 +2344,6 @@ def Unpack(self, parameters): def _is_unpack(obj): return isinstance(obj, _UnpackAlias) -else: # 3.8 - class _UnpackAlias(typing._GenericAlias, _root=True): - __class__ = typing.TypeVar - - @property - def __typing_unpacked_tuple_args__(self): - assert self.__origin__ is Unpack - assert len(self.__args__) == 1 - arg, = self.__args__ - if isinstance(arg, typing._GenericAlias): - if arg.__origin__ is not tuple: - raise TypeError("Unpack[...] must be used with a tuple type") - return arg.__args__ - return None - - @property - def __typing_is_unpacked_typevartuple__(self): - assert self.__origin__ is Unpack - assert len(self.__args__) == 1 - return isinstance(self.__args__[0], TypeVarTuple) - - def __getitem__(self, args): - if self.__typing_is_unpacked_typevartuple__: - return args - return super().__getitem__(args) - - class _UnpackForm(_ExtensionsSpecialForm, _root=True): - def __getitem__(self, parameters): - item = typing._type_check(parameters, - f'{self._name} accepts only a single type.') - return _UnpackAlias(self, (item,)) - - Unpack = _UnpackForm('Unpack', doc=_UNPACK_DOC) - - def _is_unpack(obj): - return isinstance(obj, _UnpackAlias) - def _unpack_args(*args): newargs = [] @@ -3545,10 +3113,6 @@ def _make_nmtuple(name, types, module, defaults=()): nm_tpl = collections.namedtuple(name, fields, defaults=defaults, module=module) nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations - # The `_field_types` attribute was removed in 3.9; - # in earlier versions, it is the same as the `__annotations__` attribute - if sys.version_info < (3, 9): - nm_tpl._field_types = annotations return nm_tpl _prohibited_namedtuple_fields = typing._prohibited @@ -3826,10 +3390,10 @@ def __ror__(self, other): if sys.version_info >= (3, 14): TypeAliasType = typing.TypeAliasType -# 3.8-3.13 +# <=3.13 else: if sys.version_info >= (3, 12): - # 3.12-3.14 + # 3.12-3.13 def _is_unionable(obj): """Corresponds to is_unionable() in unionobject.c in CPython.""" return obj is None or isinstance(obj, ( @@ -3840,7 +3404,7 @@ def _is_unionable(obj): TypeAliasType, )) else: - # 3.8-3.11 + # <=3.11 def _is_unionable(obj): """Corresponds to is_unionable() in unionobject.c in CPython.""" return obj is None or isinstance(obj, ( @@ -3875,11 +3439,6 @@ def __getattr__(self, attr): return object.__getattr__(self, attr) return getattr(self.__origin__, attr) - if sys.version_info < (3, 9): - def __getitem__(self, item): - result = super().__getitem__(item) - result.__class__ = type(self) - return result class TypeAliasType: """Create named, parameterized type aliases. @@ -3922,7 +3481,7 @@ def __init__(self, name: str, value, *, type_params=()): for type_param in type_params: if ( not isinstance(type_param, (TypeVar, TypeVarTuple, ParamSpec)) - # 3.8-3.11 + # <=3.11 # Unpack Backport passes isinstance(type_param, TypeVar) or _is_unpack(type_param) ): @@ -4510,12 +4069,6 @@ def evaluate_forward_ref( for tvar in type_params: if tvar.__name__ not in locals: # lets not overwrite something present locals[tvar.__name__] = tvar - if sys.version_info < (3, 9): - return typing._eval_type( - type_, - globals, - locals, - ) if sys.version_info < (3, 12, 5): return typing._eval_type( type_, @@ -4547,6 +4100,7 @@ def evaluate_forward_ref( # so that we get a CI error if one of these is deleted from typing.py # in a future version of Python AbstractSet = typing.AbstractSet +Annotated = typing.Annotated AnyStr = typing.AnyStr BinaryIO = typing.BinaryIO Callable = typing.Callable From 7ab72d7a9dfd7f0f247672ab561d09e262d99aa0 Mon Sep 17 00:00:00 2001 From: Jelle Zijlstra Date: Thu, 17 Apr 2025 09:30:04 -0700 Subject: [PATCH 2/4] Add back _AnnotatedAlias (#587) Fixes #586 --- src/test_typing_extensions.py | 5 +++++ src/typing_extensions.py | 5 ++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index a6948951..095505aa 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -5251,6 +5251,11 @@ def test_nested_annotated_with_unhashable_metadata(self): self.assertEqual(X.__origin__, List[Annotated[str, {"unhashable_metadata"}]]) self.assertEqual(X.__metadata__, ("metadata",)) + def test_compatibility(self): + # Test that the _AnnotatedAlias compatibility alias works + self.assertTrue(hasattr(typing_extensions, "_AnnotatedAlias")) + self.assertIs(typing_extensions._AnnotatedAlias, typing._AnnotatedAlias) + class GetTypeHintsTests(BaseTestCase): def test_get_type_hints(self): diff --git a/src/typing_extensions.py b/src/typing_extensions.py index f8b2f76e..1c968f72 100644 --- a/src/typing_extensions.py +++ b/src/typing_extensions.py @@ -4095,7 +4095,7 @@ def evaluate_forward_ref( ) -# Aliases for items that have always been in typing. +# Aliases for items that are in typing in all supported versions. # Explicitly assign these (rather than using `from typing import *` at the top), # so that we get a CI error if one of these is deleted from typing.py # in a future version of Python @@ -4136,3 +4136,6 @@ def evaluate_forward_ref( cast = typing.cast no_type_check = typing.no_type_check no_type_check_decorator = typing.no_type_check_decorator +# This is private, but it was defined by typing_extensions for a long time +# and some users rely on it. +_AnnotatedAlias = typing._AnnotatedAlias From 28f08acd0c44a8d533c6d5cebc59cfc82ad18047 Mon Sep 17 00:00:00 2001 From: Victorien <65306057+Viicos@users.noreply.github.com> Date: Fri, 25 Apr 2025 18:53:45 +0200 Subject: [PATCH 3/4] Implement support for PEP 764 (inline typed dictionaries) (#580) --- CHANGELOG.md | 2 + src/test_typing_extensions.py | 57 ++++++++++++ src/typing_extensions.py | 157 +++++++++++++++++++++------------- 3 files changed, 157 insertions(+), 59 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 560971ad..2ea7c833 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,8 @@ # Unreleased - Drop support for Python 3.8 (including PyPy-3.8). Patch by [Victorien Plot](https://github.com/Viicos). +- Add support for inline typed dictionaries ([PEP 764](https://peps.python.org/pep-0764/)). + Patch by [Victorien Plot](https://github.com/Viicos). # Release 4.13.2 (April 10, 2025) diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index 095505aa..a542aa75 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -5066,6 +5066,63 @@ def test_cannot_combine_closed_and_extra_items(self): class TD(TypedDict, closed=True, extra_items=range): x: str + def test_typed_dict_signature(self): + self.assertListEqual( + list(inspect.signature(TypedDict).parameters), + ['typename', 'fields', 'total', 'closed', 'extra_items', 'kwargs'] + ) + + def test_inline_too_many_arguments(self): + with self.assertRaises(TypeError): + TypedDict[{"a": int}, "extra"] + + def test_inline_not_a_dict(self): + with self.assertRaises(TypeError): + TypedDict["not_a_dict"] + + # a tuple of elements isn't allowed, even if the first element is a dict: + with self.assertRaises(TypeError): + TypedDict[({"key": int},)] + + def test_inline_empty(self): + TD = TypedDict[{}] + self.assertIs(TD.__total__, True) + self.assertIs(TD.__closed__, True) + self.assertEqual(TD.__extra_items__, NoExtraItems) + self.assertEqual(TD.__required_keys__, set()) + self.assertEqual(TD.__optional_keys__, set()) + self.assertEqual(TD.__readonly_keys__, set()) + self.assertEqual(TD.__mutable_keys__, set()) + + def test_inline(self): + TD = TypedDict[{ + "a": int, + "b": Required[int], + "c": NotRequired[int], + "d": ReadOnly[int], + }] + self.assertIsSubclass(TD, dict) + self.assertIsSubclass(TD, typing.MutableMapping) + self.assertNotIsSubclass(TD, collections.abc.Sequence) + self.assertTrue(is_typeddict(TD)) + self.assertEqual(TD.__name__, "") + self.assertEqual( + TD.__annotations__, + {"a": int, "b": Required[int], "c": NotRequired[int], "d": ReadOnly[int]}, + ) + self.assertEqual(TD.__module__, __name__) + self.assertEqual(TD.__bases__, (dict,)) + self.assertIs(TD.__total__, True) + self.assertIs(TD.__closed__, True) + self.assertEqual(TD.__extra_items__, NoExtraItems) + self.assertEqual(TD.__required_keys__, {"a", "b", "d"}) + self.assertEqual(TD.__optional_keys__, {"c"}) + self.assertEqual(TD.__readonly_keys__, {"d"}) + self.assertEqual(TD.__mutable_keys__, {"a", "b", "c"}) + + inst = TD(a=1, b=2, d=3) + self.assertIs(type(inst), dict) + self.assertEqual(inst["a"], 1) class AnnotatedTests(BaseTestCase): diff --git a/src/typing_extensions.py b/src/typing_extensions.py index 1c968f72..b541bac5 100644 --- a/src/typing_extensions.py +++ b/src/typing_extensions.py @@ -846,13 +846,6 @@ def __round__(self, ndigits: int = 0) -> T_co: pass -def _ensure_subclassable(mro_entries): - def inner(obj): - obj.__mro_entries__ = mro_entries - return obj - return inner - - _NEEDS_SINGLETONMETA = ( not hasattr(typing, "NoDefault") or not hasattr(typing, "NoExtraItems") ) @@ -1078,17 +1071,94 @@ def __subclasscheck__(cls, other): _TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {}) - @_ensure_subclassable(lambda bases: (_TypedDict,)) - def TypedDict( + def _create_typeddict( typename, - fields=_marker, + fields, /, *, - total=True, - closed=None, - extra_items=NoExtraItems, - **kwargs + typing_is_inline, + total, + closed, + extra_items, + **kwargs, ): + if fields is _marker or fields is None: + if fields is _marker: + deprecated_thing = ( + "Failing to pass a value for the 'fields' parameter" + ) + else: + deprecated_thing = "Passing `None` as the 'fields' parameter" + + example = f"`{typename} = TypedDict({typename!r}, {{}})`" + deprecation_msg = ( + f"{deprecated_thing} is deprecated and will be disallowed in " + "Python 3.15. To create a TypedDict class with 0 fields " + "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 and closed is not None: + kwargs["closed"] = closed + 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," + " but not both") + if kwargs: + if sys.version_info >= (3, 13): + raise TypeError("TypedDict takes no keyword arguments") + warnings.warn( + "The kwargs-based syntax for TypedDict definitions is deprecated " + "in Python 3.11, will be removed in Python 3.13, and may not be " + "understood by third-party type checkers.", + DeprecationWarning, + stacklevel=2, + ) + + ns = {'__annotations__': dict(fields)} + module = _caller(depth=5 if typing_is_inline else 3) + if module is not None: + # Setting correct module is necessary to make typed dict classes + # pickleable. + ns['__module__'] = module + + td = _TypedDictMeta(typename, (), ns, total=total, closed=closed, + extra_items=extra_items) + td.__orig_bases__ = (TypedDict,) + return td + + class _TypedDictSpecialForm(_ExtensionsSpecialForm, _root=True): + def __call__( + self, + typename, + fields=_marker, + /, + *, + total=True, + closed=None, + extra_items=NoExtraItems, + **kwargs + ): + return _create_typeddict( + typename, + fields, + typing_is_inline=False, + total=total, + closed=closed, + extra_items=extra_items, + **kwargs, + ) + + def __mro_entries__(self, bases): + return (_TypedDict,) + + @_TypedDictSpecialForm + def TypedDict(self, args): """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 @@ -1135,52 +1205,20 @@ class Point2D(TypedDict): See PEP 655 for more details on Required and NotRequired. """ - if fields is _marker or fields is None: - if fields is _marker: - deprecated_thing = "Failing to pass a value for the 'fields' parameter" - else: - deprecated_thing = "Passing `None` as the 'fields' parameter" - - example = f"`{typename} = TypedDict({typename!r}, {{}})`" - deprecation_msg = ( - f"{deprecated_thing} is deprecated and will be disallowed in " - "Python 3.15. To create a TypedDict class with 0 fields " - "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 and closed is not None: - kwargs["closed"] = closed - 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," - " but not both") - if kwargs: - if sys.version_info >= (3, 13): - raise TypeError("TypedDict takes no keyword arguments") - warnings.warn( - "The kwargs-based syntax for TypedDict definitions is deprecated " - "in Python 3.11, will be removed in Python 3.13, and may not be " - "understood by third-party type checkers.", - DeprecationWarning, - stacklevel=2, + # This runs when creating inline TypedDicts: + if not isinstance(args, dict): + raise TypeError( + "TypedDict[...] should be used with a single dict argument" ) - ns = {'__annotations__': dict(fields)} - module = _caller() - if module is not None: - # Setting correct module is necessary to make typed dict classes pickleable. - ns['__module__'] = module - - td = _TypedDictMeta(typename, (), ns, total=total, closed=closed, - extra_items=extra_items) - td.__orig_bases__ = (TypedDict,) - return td + return _create_typeddict( + "", + args, + typing_is_inline=True, + total=True, + closed=True, + extra_items=NoExtraItems, + ) _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta) @@ -3194,7 +3232,6 @@ def _namedtuple_mro_entries(bases): assert NamedTuple in bases return (_NamedTuple,) - @_ensure_subclassable(_namedtuple_mro_entries) def NamedTuple(typename, fields=_marker, /, **kwargs): """Typed version of namedtuple. @@ -3260,6 +3297,8 @@ class Employee(NamedTuple): nt.__orig_bases__ = (NamedTuple,) return nt + NamedTuple.__mro_entries__ = _namedtuple_mro_entries + if hasattr(collections.abc, "Buffer"): Buffer = collections.abc.Buffer From f02b99d3be02ef8b308503641d537ff16884b360 Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 30 Apr 2025 15:08:13 +0200 Subject: [PATCH 4/4] Add Reader and Writer protocols (#582) --- CHANGELOG.md | 6 ++++++ doc/conf.py | 4 +++- doc/index.rst | 12 +++++++++++ src/test_typing_extensions.py | 26 ++++++++++++++++++++++++ src/typing_extensions.py | 38 +++++++++++++++++++++++++++++++++++ 5 files changed, 85 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ea7c833..8f9523f1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,13 @@ # Unreleased - Drop support for Python 3.8 (including PyPy-3.8). Patch by [Victorien Plot](https://github.com/Viicos). + +New features: + - Add support for inline typed dictionaries ([PEP 764](https://peps.python.org/pep-0764/)). Patch by [Victorien Plot](https://github.com/Viicos). +- Add `typing_extensions.Reader` and `typing_extensions.Writer`. Patch by + Sebastian Rittau. # Release 4.13.2 (April 10, 2025) @@ -17,6 +22,7 @@ # Release 4.13.1 (April 3, 2025) Bugfixes: + - Fix regression in 4.13.0 on Python 3.10.2 causing a `TypeError` when using `Concatenate`. Patch by [Daraan](https://github.com/Daraan). - Fix `TypeError` when using `evaluate_forward_ref` on Python 3.10.1-2 and 3.9.8-10. diff --git a/doc/conf.py b/doc/conf.py index cbb15a70..db9b5185 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -27,7 +27,9 @@ templates_path = ['_templates'] exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] -intersphinx_mapping = {'py': ('https://docs.python.org/3', None)} +# This should usually point to /3, unless there is a necessity to link to +# features in future versions of Python. +intersphinx_mapping = {'py': ('https://docs.python.org/3.14', None)} add_module_names = False diff --git a/doc/index.rst b/doc/index.rst index e652c9e4..325182eb 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -659,6 +659,18 @@ Protocols .. versionadded:: 4.6.0 +.. class:: Reader + + See :py:class:`io.Reader`. Added to the standard library in Python 3.14. + + .. versionadded:: 4.14.0 + +.. class:: Writer + + See :py:class:`io.Writer`. Added to the standard library in Python 3.14. + + .. versionadded:: 4.14.0 + Decorators ~~~~~~~~~~ diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index a542aa75..01e2b270 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -4103,6 +4103,32 @@ def foo(self): pass self.assertIsSubclass(Bar, Functor) +class SpecificProtocolTests(BaseTestCase): + def test_reader_runtime_checkable(self): + class MyReader: + def read(self, n: int) -> bytes: + return b"" + + class WrongReader: + def readx(self, n: int) -> bytes: + return b"" + + self.assertIsInstance(MyReader(), typing_extensions.Reader) + self.assertNotIsInstance(WrongReader(), typing_extensions.Reader) + + def test_writer_runtime_checkable(self): + class MyWriter: + def write(self, b: bytes) -> int: + return 0 + + class WrongWriter: + def writex(self, b: bytes) -> int: + return 0 + + self.assertIsInstance(MyWriter(), typing_extensions.Writer) + self.assertNotIsInstance(WrongWriter(), typing_extensions.Writer) + + class Point2DGeneric(Generic[T], TypedDict): a: T b: T diff --git a/src/typing_extensions.py b/src/typing_extensions.py index b541bac5..f2bee507 100644 --- a/src/typing_extensions.py +++ b/src/typing_extensions.py @@ -6,6 +6,7 @@ import enum import functools import inspect +import io import keyword import operator import sys @@ -56,6 +57,8 @@ 'SupportsIndex', 'SupportsInt', 'SupportsRound', + 'Reader', + 'Writer', # One-off things. 'Annotated', @@ -846,6 +849,41 @@ def __round__(self, ndigits: int = 0) -> T_co: pass +if hasattr(io, "Reader") and hasattr(io, "Writer"): + Reader = io.Reader + Writer = io.Writer +else: + @runtime_checkable + class Reader(Protocol[T_co]): + """Protocol for simple I/O reader instances. + + This protocol only supports blocking I/O. + """ + + __slots__ = () + + @abc.abstractmethod + def read(self, size: int = ..., /) -> T_co: + """Read data from the input stream and return it. + + If *size* is specified, at most *size* items (bytes/characters) will be + read. + """ + + @runtime_checkable + class Writer(Protocol[T_contra]): + """Protocol for simple I/O writer instances. + + This protocol only supports blocking I/O. + """ + + __slots__ = () + + @abc.abstractmethod + def write(self, data: T_contra, /) -> int: + """Write *data* to the output stream and return the number of items written.""" # noqa: E501 + + _NEEDS_SINGLETONMETA = ( not hasattr(typing, "NoDefault") or not hasattr(typing, "NoExtraItems") )