Dec 2, 2023 · Dec 2, 2023 · Dec 2, 2023 · Dec 2, 2023 · Dec 2, 2023 · Dec 2, 2023
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
        self.assertEqual(X.__mro__, (X, int, object),
                         "Annotated should be transparent.")

    def test_annotated_cached_with_types(self):
        class A(str): ...
        class B(str): ...

        field_a1 = Annotated[str, A("X")]
        field_a2 = Annotated[str, B("X")]
        a1_metadata = field_a1.__metadata__[0]
        a2_metadata = field_a2.__metadata__[0]

        self.assertIs(type(a1_metadata), A)
        self.assertEqual(a1_metadata, A("X"))
        self.assertIs(type(a2_metadata), B)
        self.assertEqual(a2_metadata, B("X"))
        self.assertIsNot(type(a1_metadata), type(a2_metadata))

        field_b1 = Annotated[str, A("Y")]
        field_b2 = Annotated[str, B("Y")]
        b1_metadata = field_b1.__metadata__[0]
        b2_metadata = field_b2.__metadata__[0]

        self.assertIs(type(b1_metadata), A)
        self.assertEqual(b1_metadata, A("Y"))
        self.assertIs(type(b2_metadata), B)
        self.assertEqual(b2_metadata, B("Y"))
        self.assertIsNot(type(b1_metadata), type(b2_metadata))

        field_c1 = Annotated[int, 1]
        field_c2 = Annotated[int, 1.0]
        field_c3 = Annotated[int, True]

        self.assertIs(type(field_c1.__metadata__[0]), int)
        self.assertIs(type(field_c2.__metadata__[0]), float)
        self.assertIs(type(field_c3.__metadata__[0]), bool)


 class TypeAliasTests(BaseTestCase):
    def test_canonical_usage_with_variable_annotation(self):
diff --git a/Lib/typing.py b/Lib/typing.py
        return self._getitem(self, parameters)


 class_LiteralSpecialForm(_SpecialForm, _root=True):
 class_TypedCacheSpecialForm(_SpecialForm, _root=True):
    def __getitem__(self, parameters):
        if not isinstance(parameters, tuple):
            parameters = (parameters,)
    arg = _type_check(parameters, f"{self} requires a single type.")
    return Union[arg, type(None)]

 @_LiteralSpecialForm
 @_TypedCacheSpecialForm
 @_tp_cache(typed=True)
 def Literal(self, *parameters):
    """Special typing form to define literal types (a.k.a. value types).
        return (self.__origin__,)


 @_SpecialForm
 def Annotated(self, params):
 @_TypedCacheSpecialForm
 @_tp_cache(typed=True)
 def Annotated(self, *params):
    """Add context-specific metadata to a type.

    Example: Annotated[int, runtime_check.Unsigned] indicates to the
      where T1, T2 etc. are TypeVars, which would be invalid, because
      only one type should be passed to Annotated.
    """
    ifnot isinstance(params, tuple) orlen(params) < 2:
    if len(params) < 2:
        raise TypeError("Annotated[...] should be used "
                        "with at least two arguments (a type and an "
                        "annotation).")
diff --git a/Misc/NEWS.d/next/Library/2023-12-02-12-55-17.gh-issue-112618.7_FT8-.rst b/Misc/NEWS.d/next/Library/2023-12-02-12-55-17.gh-issue-112618.7_FT8-.rst
 Fix a caching bug relating to :data:`typing.Annotated`.
 ``Annotated[str, True]`` is no longer identical to ``Annotated[str, 1]``.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -8675,6 +8675,40 @@ class X(Annotated[int, (1, 10)]): ...
		self.assertEqual(X.__mro__, (X, int, object),
		"Annotated should be transparent.")

		def test_annotated_cached_with_types(self):
		class A(str): ...
		class B(str): ...

		field_a1 = Annotated[str, A("X")]
		field_a2 = Annotated[str, B("X")]
		a1_metadata = field_a1.__metadata__[0]
		a2_metadata = field_a2.__metadata__[0]

		self.assertIs(type(a1_metadata), A)
		self.assertEqual(a1_metadata, A("X"))
		self.assertIs(type(a2_metadata), B)
		self.assertEqual(a2_metadata, B("X"))
		self.assertIsNot(type(a1_metadata), type(a2_metadata))

		field_b1 = Annotated[str, A("Y")]
		field_b2 = Annotated[str, B("Y")]
		b1_metadata = field_b1.__metadata__[0]
		b2_metadata = field_b2.__metadata__[0]

		self.assertIs(type(b1_metadata), A)
		self.assertEqual(b1_metadata, A("Y"))
		self.assertIs(type(b2_metadata), B)
		self.assertEqual(b2_metadata, B("Y"))
		self.assertIsNot(type(b1_metadata), type(b2_metadata))

		field_c1 = Annotated[int, 1]
		field_c2 = Annotated[int, 1.0]
		field_c3 = Annotated[int, True]

		self.assertIs(type(field_c1.__metadata__[0]), int)
		self.assertIs(type(field_c2.__metadata__[0]), float)
		self.assertIs(type(field_c3.__metadata__[0]), bool)


		class TypeAliasTests(BaseTestCase):
		def test_canonical_usage_with_variable_annotation(self):
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -490,7 +490,7 @@ def __getitem__(self, parameters):
		return self._getitem(self, parameters)


		class_LiteralSpecialForm(_SpecialForm, _root=True):
		class_TypedCacheSpecialForm(_SpecialForm, _root=True):
		def __getitem__(self, parameters):
		if not isinstance(parameters, tuple):
		parameters = (parameters,)
Expand DownExpand Up		@@ -723,7 +723,7 @@ def Optional(self, parameters):
		arg = _type_check(parameters, f"{self} requires a single type.")
		return Union[arg, type(None)]

		@_LiteralSpecialForm
		@_TypedCacheSpecialForm
		@_tp_cache(typed=True)
		def Literal(self, *parameters):
		"""Special typing form to define literal types (a.k.a. value types).
Expand DownExpand Up		@@ -2005,8 +2005,9 @@ def __mro_entries__(self, bases):
		return (self.__origin__,)


		@_SpecialForm
		def Annotated(self, params):
		@_TypedCacheSpecialForm
		@_tp_cache(typed=True)
		def Annotated(self, *params):
		"""Add context-specific metadata to a type.

		Example: Annotated[int, runtime_check.Unsigned] indicates to the
Expand DownExpand Up		@@ -2053,7 +2054,7 @@ def Annotated(self, params):
		where T1, T2 etc. are TypeVars, which would be invalid, because
		only one type should be passed to Annotated.
		"""
		ifnot isinstance(params, tuple) orlen(params) < 2:
		if len(params) < 2:
		raise TypeError("Annotated[...] should be used "
		"with at least two arguments (a type and an "
		"annotation).")
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Fix a caching bug relating to :data:`typing.Annotated`.
		``Annotated[str, True]`` is no longer identical to ``Annotated[str, 1]``.