commit: 4e9709a1ac4bfdad86b25d70b5b1d609221a64c4 Author: Michał Górny <mgorny <AT> gentoo <DOT> org> AuthorDate: Fri May 9 01:00:21 2025 +0000 Commit: Michał Górny <mgorny <AT> gentoo <DOT> org> CommitDate: Fri May 9 01:00:21 2025 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=4e9709a1
dev-python/typing-extensions: Reverts "add missing patch" No clue why but the diff with the tested patch is pretty large. Reverts: 96ce6d9ee301206926396d1f99fcb9b2bb7b0caa Signed-off-by: Michał Górny <mgorny <AT> gentoo.org> .../files/typing-extensions-4.13.2-py314.patch | 596 --------------------- 1 file changed, 596 deletions(-) diff --git a/dev-python/typing-extensions/files/typing-extensions-4.13.2-py314.patch b/dev-python/typing-extensions/files/typing-extensions-4.13.2-py314.patch deleted file mode 100644 index e19a86f61e29..000000000000 --- a/dev-python/typing-extensions/files/typing-extensions-4.13.2-py314.patch +++ /dev/null @@ -1,596 +0,0 @@ -https://github.com/python/typing_extensions/pull/566 -https://github.com/python/typing_extensions/pull/592 -(CI bits dropped, test_fwdref_value_is_cached hunk added at the end as -didn't apply cleanly.) - -From 32dde8e38975df88336107b112300483325010ef Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Tue, 1 Apr 2025 08:26:52 -0700 -Subject: [PATCH 1/3] Fix test failures on Python 3.14 - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -882,10 +882,12 @@ async def coro(self): - - class DeprecatedCoroTests(BaseTestCase): - def test_asyncio_iscoroutinefunction(self): -- self.assertFalse(asyncio.coroutines.iscoroutinefunction(func)) -- self.assertFalse(asyncio.coroutines.iscoroutinefunction(Cls.func)) -- self.assertTrue(asyncio.coroutines.iscoroutinefunction(coro)) -- self.assertTrue(asyncio.coroutines.iscoroutinefunction(Cls.coro)) -+ with warnings.catch_warnings(): -+ warnings.simplefilter("ignore", DeprecationWarning) -+ self.assertFalse(asyncio.coroutines.iscoroutinefunction(func)) -+ self.assertFalse(asyncio.coroutines.iscoroutinefunction(Cls.func)) -+ self.assertTrue(asyncio.coroutines.iscoroutinefunction(coro)) -+ self.assertTrue(asyncio.coroutines.iscoroutinefunction(Cls.coro)) - - @skipUnless(TYPING_3_12_ONLY or TYPING_3_13_0_RC, "inspect.iscoroutinefunction works differently on Python < 3.12") - def test_inspect_iscoroutinefunction(self): -@@ -7209,7 +7211,7 @@ def test_cannot_instantiate_vars(self): - - def test_bound_errors(self): - with self.assertRaises(TypeError): -- TypeVar('X', bound=Union) -+ TypeVar('X', bound=Optional) - with self.assertRaises(TypeError): - TypeVar('X', str, float, bound=Employee) - with self.assertRaisesRegex(TypeError, -@@ -8190,19 +8192,25 @@ def f2(a: "undefined"): # noqa: F821 - get_annotations(f2, format=Format.FORWARDREF), - {"a": "undefined"}, - ) -- self.assertEqual(get_annotations(f2, format=2), {"a": "undefined"}) -+ self.assertEqual( -+ get_annotations(f2, format=Format.FORWARDREF.value), -+ {"a": "undefined"}, -+ ) - - self.assertEqual( - get_annotations(f1, format=Format.STRING), - {"a": "int"}, - ) -- self.assertEqual(get_annotations(f1, format=3), {"a": "int"}) -+ self.assertEqual( -+ get_annotations(f1, format=Format.STRING.value), -+ {"a": "int"}, -+ ) - - with self.assertRaises(ValueError): - get_annotations(f1, format=0) - - with self.assertRaises(ValueError): -- get_annotations(f1, format=4) -+ get_annotations(f1, format=42) - - def test_custom_object_with_annotations(self): - class C: -@@ -8240,6 +8248,8 @@ def foo(a: int, b: str): - - foo.__annotations__ = {"a": "foo", "b": "str"} - for format in Format: -+ if format is Format.VALUE_WITH_FAKE_GLOBALS: -+ continue - with self.subTest(format=format): - self.assertEqual( - get_annotations(foo, format=format), ---- a/src/typing_extensions.py -+++ b/src/typing_extensions.py -@@ -4139,8 +4139,9 @@ def __eq__(self, other: object) -> bool: - - class Format(enum.IntEnum): - VALUE = 1 -- FORWARDREF = 2 -- STRING = 3 -+ VALUE_WITH_FAKE_GLOBALS = 2 -+ FORWARDREF = 3 -+ STRING = 4 - - - if _PEP_649_OR_749_IMPLEMENTED: -@@ -4184,6 +4185,8 @@ def get_annotations(obj, *, globals=None, locals=None, eval_str=False, - - """ - format = Format(format) -+ if format is Format.VALUE_WITH_FAKE_GLOBALS: -+ raise ValueError("The VALUE_WITH_FAKE_GLOBALS format is for internal use only") - - if eval_str and format is not Format.VALUE: - raise ValueError("eval_str=True is only supported with format=Format.VALUE") - -From c98e556ee2e4c7b9964297d827ef57da4d916b3d Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Tue, 1 Apr 2025 08:31:01 -0700 -Subject: [PATCH 2/3] test & lint - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -8248,13 +8248,18 @@ def foo(a: int, b: str): - - foo.__annotations__ = {"a": "foo", "b": "str"} - for format in Format: -- if format is Format.VALUE_WITH_FAKE_GLOBALS: -- continue - with self.subTest(format=format): -- self.assertEqual( -- get_annotations(foo, format=format), -- {"a": "foo", "b": "str"}, -- ) -+ if format is Format.VALUE_WITH_FAKE_GLOBALS: -+ with self.assertRaisesRegex( -+ ValueError, -+ "The VALUE_WITH_FAKE_GLOBALS format is for internal use only" -+ ): -+ get_annotations(foo, format=format) -+ else: -+ self.assertEqual( -+ get_annotations(foo, format=format), -+ {"a": "foo", "b": "str"}, -+ ) - - self.assertEqual( - get_annotations(foo, eval_str=True, locals=locals()), ---- a/src/typing_extensions.py -+++ b/src/typing_extensions.py -@@ -4186,7 +4186,9 @@ def get_annotations(obj, *, globals=None, locals=None, eval_str=False, - """ - format = Format(format) - if format is Format.VALUE_WITH_FAKE_GLOBALS: -- raise ValueError("The VALUE_WITH_FAKE_GLOBALS format is for internal use only") -+ raise ValueError( -+ "The VALUE_WITH_FAKE_GLOBALS format is for internal use only" -+ ) - - if eval_str and format is not Format.VALUE: - raise ValueError("eval_str=True is only supported with format=Format.VALUE") - -From adfb57a83f358e26905531407edf99a7346e22fc Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Thu, 10 Apr 2025 07:09:20 -0700 -Subject: [PATCH 3/3] Update src/test_typing_extensions.py - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -8196,6 +8196,7 @@ def f2(a: "undefined"): # noqa: F821 - get_annotations(f2, format=Format.FORWARDREF), - {"a": "undefined"}, - ) -+ # Test that the raw int also works - self.assertEqual( - get_annotations(f2, format=Format.FORWARDREF.value), - {"a": "undefined"}, -From 610ad76f7c4b8ff67deb6d688c00ccc7530ef363 Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Mon, 5 May 2025 07:52:14 -0700 -Subject: [PATCH 1/5] Fix 3.14 - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -5152,6 +5152,65 @@ def test_inline(self): - self.assertIs(type(inst), dict) - self.assertEqual(inst["a"], 1) - -+ def test_annotations(self): -+ # _type_check is applied -+ with self.assertRaisesRegex(TypeError, "Plain typing.Final is not valid as type argument"): -+ class X(TypedDict): -+ a: Final -+ -+ # _type_convert is applied -+ class Y(TypedDict): -+ a: None -+ b: "int" -+ if sys.version_info >= (3, 14): -+ import annotationlib -+ from test.support import EqualToForwardRef -+ -+ fwdref = EqualToForwardRef('int', module=__name__) -+ self.assertEqual(Y.__annotations__, {'a': type(None), 'b': fwdref}) -+ self.assertEqual(Y.__annotate__(annotationlib.Format.FORWARDREF), {'a': type(None), 'b': fwdref}) -+ else: -+ self.assertEqual(Y.__annotations__, {'a': type(None), 'b': typing.ForwardRef('int', module=__name__)}) -+ -+ @skipUnless(TYPING_3_14_0, "Only supported on 3.14") -+ def test_delayed_type_check(self): -+ # _type_check is also applied later -+ class Z(TypedDict): -+ a: undefined -+ -+ with self.assertRaises(NameError): -+ Z.__annotations__ -+ -+ undefined = Final -+ with self.assertRaisesRegex(TypeError, "Plain typing.Final is not valid as type argument"): -+ Z.__annotations__ -+ -+ undefined = None -+ self.assertEqual(Z.__annotations__, {'a': type(None)}) -+ -+ @skipUnless(TYPING_3_14_0, "Only supported on 3.14") -+ def test_deferred_evaluation(self): -+ class A(TypedDict): -+ x: NotRequired[undefined] -+ y: ReadOnly[undefined] -+ z: Required[undefined] -+ -+ self.assertEqual(A.__required_keys__, frozenset({'y', 'z'})) -+ self.assertEqual(A.__optional_keys__, frozenset({'x'})) -+ self.assertEqual(A.__readonly_keys__, frozenset({'y'})) -+ self.assertEqual(A.__mutable_keys__, frozenset({'x', 'z'})) -+ -+ with self.assertRaises(NameError): -+ A.__annotations__ -+ -+ import annotationlib -+ self.assertEqual( -+ A.__annotate__(annotationlib.Format.STRING), -+ {'x': 'NotRequired[undefined]', 'y': 'ReadOnly[undefined]', -+ 'z': 'Required[undefined]'}, -+ ) -+ -+ - class AnnotatedTests(BaseTestCase): - - def test_repr(self): -@@ -8956,7 +9008,7 @@ class Y(Generic[Tx]): - self.assertEqual(get_args(evaluated_ref1b), (Y[Tx],)) - - with self.subTest("nested string of TypeVar"): -- evaluated_ref2 = evaluate_forward_ref(typing.ForwardRef("""Y["Y['Tx']"]"""), locals={"Y": Y}) -+ evaluated_ref2 = evaluate_forward_ref(typing.ForwardRef("""Y["Y['Tx']"]"""), locals={"Y": Y, "Tx": Tx}) - self.assertEqual(get_origin(evaluated_ref2), Y) - self.assertEqual(get_args(evaluated_ref2), (Y[Tx],)) - ---- a/src/typing_extensions.py -+++ b/src/typing_extensions.py -@@ -14,6 +14,9 @@ - import typing - import warnings - -+if sys.version_info >= (3, 14): -+ import annotationlib -+ - __all__ = [ - # Super-special typing primitives. - 'Any', -@@ -1018,21 +1021,27 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, - tp_dict.__orig_bases__ = bases - - annotations = {} -+ own_annotate = None - if "__annotations__" in ns: - own_annotations = ns["__annotations__"] -- elif "__annotate__" in ns: -- # TODO: Use inspect.VALUE here, and make the annotations lazily evaluated -- own_annotations = ns["__annotate__"](1) -+ elif sys.version_info >= (3, 14): -+ own_annotate = annotationlib.get_annotate_from_class_namespace(ns) -+ if own_annotate is not None: -+ own_annotations = annotationlib.call_annotate_function( -+ own_annotate, annotationlib.Format.FORWARDREF, owner=tp_dict -+ ) -+ else: -+ own_annotations = {} - else: - own_annotations = {} - msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type" - if _TAKES_MODULE: -- own_annotations = { -+ own_checked_annotations = { - n: typing._type_check(tp, msg, module=tp_dict.__module__) - for n, tp in own_annotations.items() - } - else: -- own_annotations = { -+ own_checked_annotations = { - n: typing._type_check(tp, msg) - for n, tp in own_annotations.items() - } -@@ -1045,7 +1054,8 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, - for base in bases: - base_dict = base.__dict__ - -- annotations.update(base_dict.get('__annotations__', {})) -+ if sys.version_info <= (3, 14): -+ annotations.update(base_dict.get('__annotations__', {})) - required_keys.update(base_dict.get('__required_keys__', ())) - optional_keys.update(base_dict.get('__optional_keys__', ())) - readonly_keys.update(base_dict.get('__readonly_keys__', ())) -@@ -1055,8 +1065,8 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, - # is retained for backwards compatibility, but only for Python - # 3.13 and lower. - if (closed and sys.version_info < (3, 14) -- and "__extra_items__" in own_annotations): -- annotation_type = own_annotations.pop("__extra_items__") -+ and "__extra_items__" in own_checked_annotations): -+ annotation_type = own_checked_annotations.pop("__extra_items__") - qualifiers = set(_get_typeddict_qualifiers(annotation_type)) - if Required in qualifiers: - raise TypeError( -@@ -1070,8 +1080,8 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, - ) - extra_items_type = annotation_type - -- annotations.update(own_annotations) -- for annotation_key, annotation_type in own_annotations.items(): -+ annotations.update(own_checked_annotations) -+ for annotation_key, annotation_type in own_checked_annotations.items(): - qualifiers = set(_get_typeddict_qualifiers(annotation_type)) - - if Required in qualifiers: -@@ -1089,7 +1099,38 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, - mutable_keys.add(annotation_key) - readonly_keys.discard(annotation_key) - -- tp_dict.__annotations__ = annotations -+ if sys.version_info >= (3, 14): -+ def __annotate__(format): -+ annos = {} -+ for base in bases: -+ if base is Generic: -+ continue -+ base_annotate = base.__annotate__ -+ if base_annotate is None: -+ continue -+ base_annos = annotationlib.call_annotate_function( -+ base.__annotate__, format, owner=base) -+ annos.update(base_annos) -+ if own_annotate is not None: -+ own = annotationlib.call_annotate_function( -+ own_annotate, format, owner=tp_dict) -+ if format != annotationlib.Format.STRING: -+ own = { -+ n: typing._type_check(tp, msg, module=tp_dict.__module__) -+ for n, tp in own.items() -+ } -+ elif format == annotationlib.Format.STRING: -+ own = annotationlib.annotations_to_string(own_annotations) -+ elif format in (annotationlib.Format.FORWARDREF, annotationlib.Format.VALUE): -+ own = own_checked_annotations -+ else: -+ raise NotImplementedError(format) -+ annos.update(own) -+ return annos -+ -+ tp_dict.__annotate__ = __annotate__ -+ else: -+ tp_dict.__annotations__ = annotations - tp_dict.__required_keys__ = frozenset(required_keys) - tp_dict.__optional_keys__ = frozenset(optional_keys) - tp_dict.__readonly_keys__ = frozenset(readonly_keys) - -From 83ff33aad4e53ecbd026bfdd683b3c460708e045 Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Mon, 5 May 2025 08:03:32 -0700 -Subject: [PATCH 2/5] fix lint - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -5176,7 +5176,7 @@ class Y(TypedDict): - def test_delayed_type_check(self): - # _type_check is also applied later - class Z(TypedDict): -- a: undefined -+ a: undefined # noqa: F821 - - with self.assertRaises(NameError): - Z.__annotations__ -@@ -5185,15 +5185,15 @@ class Z(TypedDict): - with self.assertRaisesRegex(TypeError, "Plain typing.Final is not valid as type argument"): - Z.__annotations__ - -- undefined = None -+ undefined = None # noqa: F841 - self.assertEqual(Z.__annotations__, {'a': type(None)}) - - @skipUnless(TYPING_3_14_0, "Only supported on 3.14") - def test_deferred_evaluation(self): - class A(TypedDict): -- x: NotRequired[undefined] -- y: ReadOnly[undefined] -- z: Required[undefined] -+ x: NotRequired[undefined] # noqa: F821 -+ y: ReadOnly[undefined] # noqa: F821 -+ z: Required[undefined] # noqa: F821 - - self.assertEqual(A.__required_keys__, frozenset({'y', 'z'})) - self.assertEqual(A.__optional_keys__, frozenset({'x'})) ---- a/src/typing_extensions.py -+++ b/src/typing_extensions.py -@@ -1025,10 +1025,14 @@ def __new__(cls, name, bases, ns, *, total=True, closed=None, - if "__annotations__" in ns: - own_annotations = ns["__annotations__"] - elif sys.version_info >= (3, 14): -- own_annotate = annotationlib.get_annotate_from_class_namespace(ns) -+ if hasattr(annotationlib, "get_annotate_from_class_namespace"): -+ own_annotate = annotationlib.get_annotate_from_class_namespace(ns) -+ else: -+ # 3.14.0a7 and earlier -+ own_annotate = ns.get("__annotate__") - if own_annotate is not None: - own_annotations = annotationlib.call_annotate_function( -- own_annotate, annotationlib.Format.FORWARDREF, owner=tp_dict -+ own_annotate, Format.FORWARDREF, owner=tp_dict - ) - else: - own_annotations = {} -@@ -1114,14 +1118,14 @@ def __annotate__(format): - if own_annotate is not None: - own = annotationlib.call_annotate_function( - own_annotate, format, owner=tp_dict) -- if format != annotationlib.Format.STRING: -+ if format != Format.STRING: - own = { - n: typing._type_check(tp, msg, module=tp_dict.__module__) - for n, tp in own.items() - } -- elif format == annotationlib.Format.STRING: -+ elif format == Format.STRING: - own = annotationlib.annotations_to_string(own_annotations) -- elif format in (annotationlib.Format.FORWARDREF, annotationlib.Format.VALUE): -+ elif format in (Format.FORWARDREF, Format.VALUE): - own = own_checked_annotations - else: - raise NotImplementedError(format) - -From d932665dc4a97d25e06b77063521baf97e89aceb Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Mon, 5 May 2025 08:06:31 -0700 -Subject: [PATCH 3/5] fix 3.9/3.10 - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -5154,9 +5154,9 @@ def test_inline(self): - - def test_annotations(self): - # _type_check is applied -- with self.assertRaisesRegex(TypeError, "Plain typing.Final is not valid as type argument"): -+ with self.assertRaisesRegex(TypeError, "Plain typing.Optional is not valid as type argument"): - class X(TypedDict): -- a: Final -+ a: Optional - - # _type_convert is applied - class Y(TypedDict): - -From 34293d775b66bc6c6370b517d11f80719fb4d316 Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Mon, 5 May 2025 08:20:26 -0700 -Subject: [PATCH 4/5] fix a7? - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -103,6 +103,11 @@ - runtime_checkable, - ) - -+if sys.version_info >= (3, 14): -+ from test.support import EqualToForwardRef -+else: -+ EqualToForwardRef = typing.ForwardRef -+ - NoneType = type(None) - T = TypeVar("T") - KT = TypeVar("KT") -@@ -5164,7 +5169,6 @@ class Y(TypedDict): - b: "int" - if sys.version_info >= (3, 14): - import annotationlib -- from test.support import EqualToForwardRef - - fwdref = EqualToForwardRef('int', module=__name__) - self.assertEqual(Y.__annotations__, {'a': type(None), 'b': fwdref}) -@@ -6022,7 +6026,7 @@ def test_substitution(self): - U2 = Unpack[Ts] - self.assertEqual(C2[U1], (str, int, str)) - self.assertEqual(C2[U2], (str, Unpack[Ts])) -- self.assertEqual(C2["U2"], (str, typing.ForwardRef("U2"))) -+ self.assertEqual(C2["U2"], (str, EqualToForwardRef("U2"))) - - if (3, 12, 0) <= sys.version_info < (3, 12, 4): - with self.assertRaises(AssertionError): -@@ -7309,8 +7313,8 @@ def test_or(self): - self.assertEqual(X | "x", Union[X, "x"]) - self.assertEqual("x" | X, Union["x", X]) - # make sure the order is correct -- self.assertEqual(get_args(X | "x"), (X, typing.ForwardRef("x"))) -- self.assertEqual(get_args("x" | X), (typing.ForwardRef("x"), X)) -+ self.assertEqual(get_args(X | "x"), (X, EqualToForwardRef("x"))) -+ self.assertEqual(get_args("x" | X), (EqualToForwardRef("x"), X)) - - def test_union_constrained(self): - A = TypeVar('A', str, bytes) -@@ -8878,7 +8882,7 @@ class X: - type_params=None, - format=Format.FORWARDREF, - ) -- self.assertEqual(evaluated_ref, typing.ForwardRef("doesnotexist2")) -+ self.assertEqual(evaluated_ref, EqualToForwardRef("doesnotexist2")) - - def test_evaluate_with_type_params(self): - # Use a T name that is not in globals - -From 993ac2fd77b89577a137819ffdb8478d25958742 Mon Sep 17 00:00:00 2001 -From: Jelle Zijlstra <[email protected]> -Date: Mon, 5 May 2025 08:24:26 -0700 -Subject: [PATCH 5/5] no support - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -103,11 +103,6 @@ - runtime_checkable, - ) - --if sys.version_info >= (3, 14): -- from test.support import EqualToForwardRef --else: -- EqualToForwardRef = typing.ForwardRef -- - NoneType = type(None) - T = TypeVar("T") - KT = TypeVar("KT") -@@ -444,6 +439,48 @@ def assertNotIsSubclass(self, cls, class_or_tuple, msg=None): - raise self.failureException(message) - - -+class EqualToForwardRef: -+ """Helper to ease use of annotationlib.ForwardRef in tests. -+ -+ This checks only attributes that can be set using the constructor. -+ -+ """ -+ -+ def __init__( -+ self, -+ arg, -+ *, -+ module=None, -+ owner=None, -+ is_class=False, -+ ): -+ self.__forward_arg__ = arg -+ self.__forward_is_class__ = is_class -+ self.__forward_module__ = module -+ self.__owner__ = owner -+ -+ def __eq__(self, other): -+ if not isinstance(other, (EqualToForwardRef, typing.ForwardRef)): -+ return NotImplemented -+ if sys.version_info >= (3, 14) and self.__owner__ != other.__owner__: -+ return False -+ return ( -+ self.__forward_arg__ == other.__forward_arg__ -+ and self.__forward_module__ == other.__forward_module__ -+ and self.__forward_is_class__ == other.__forward_is_class__ -+ ) -+ -+ def __repr__(self): -+ extra = [] -+ if self.__forward_module__ is not None: -+ extra.append(f", module={self.__forward_module__!r}") -+ if self.__forward_is_class__: -+ extra.append(", is_class=True") -+ if sys.version_info >= (3, 14) and self.__owner__ is not None: -+ extra.append(f", owner={self.__owner__!r}") -+ return f"EqualToForwardRef({self.__forward_arg__!r}{''.join(extra)})" -+ -+ - class Employee: - pass - ---- a/src/test_typing_extensions.py -+++ b/src/test_typing_extensions.py -@@ -8957,13 +8957,6 @@ class TestEvaluateForwardRefs(BaseTestCase): - obj = object() - self.assertIs(evaluate_forward_ref(typing.ForwardRef("int"), globals={"int": obj}), obj) - -- def test_fwdref_value_is_cached(self): -- fr = typing.ForwardRef("hello") -- with self.assertRaises(NameError): -- evaluate_forward_ref(fr) -- 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(
