From 203dfd83a55bed3f726d03f2dcfa8fd0c14dac52 Mon Sep 17 00:00:00 2001 From: sobolevn Date: Mon, 24 Apr 2023 11:45:13 +0300 Subject: [PATCH 1/4] Backport tests of `Union` + `Literal` from CPython --- src/test_typing_extensions.py | 79 +++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index 7fa310ce..04a260d0 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -714,6 +714,13 @@ def test_basics(self): Literal["x", "y", "z"] Literal[None] + def test_enum(self): + import enum + class My(enum.Enum): + A = 'A' + + self.assertEqual(Literal[My.A].__args__, (My.A,)) + def test_illegal_parameters_do_not_raise_runtime_errors(self): # Type checkers should reject these types, but we do not # raise errors at runtime to maintain maximum flexibility @@ -794,6 +801,64 @@ def test_args(self): # Mutable arguments will not be deduplicated self.assertEqual(Literal[[], []].__args__, ([], [])) + def test_union_of_literals(self): + self.assertEqual(Union[Literal[1], Literal[2]].__args__, + (Literal[1], Literal[2])) + self.assertEqual(Union[Literal[1], Literal[1]], + Literal[1]) + + self.assertEqual(Union[Literal[False], Literal[0]].__args__, + (Literal[False], Literal[0])) + self.assertEqual(Union[Literal[True], Literal[1]].__args__, + (Literal[True], Literal[1])) + + import enum + class Ints(enum.IntEnum): + A = 0 + B = 1 + + self.assertEqual(Union[Literal[Ints.A], Literal[Ints.B]].__args__, + (Literal[Ints.A], Literal[Ints.B])) + + self.assertEqual(Union[Literal[Ints.A], Literal[Ints.A]], + Literal[Ints.A]) + self.assertEqual(Union[Literal[Ints.B], Literal[Ints.B]], + Literal[Ints.B]) + + self.assertEqual(Union[Literal[0], Literal[Ints.A], Literal[False]].__args__, + (Literal[0], Literal[Ints.A], Literal[False])) + self.assertEqual(Union[Literal[1], Literal[Ints.B], Literal[True]].__args__, + (Literal[1], Literal[Ints.B], Literal[True])) + + def test_or_type_operator_with_Literal(self): + Literal = typing.Literal + self.assertEqual((Literal[1] | Literal[2]).__args__, + (Literal[1], Literal[2])) + + self.assertEqual((Literal[0] | Literal[False]).__args__, + (Literal[0], Literal[False])) + self.assertEqual((Literal[1] | Literal[True]).__args__, + (Literal[1], Literal[True])) + + self.assertEqual(Literal[1] | Literal[1], Literal[1]) + self.assertEqual(Literal['a'] | Literal['a'], Literal['a']) + + import enum + class Ints(enum.IntEnum): + A = 0 + B = 1 + + self.assertEqual(Literal[Ints.A] | Literal[Ints.A], Literal[Ints.A]) + self.assertEqual(Literal[Ints.B] | Literal[Ints.B], Literal[Ints.B]) + + self.assertEqual((Literal[Ints.B] | Literal[Ints.A]).__args__, + (Literal[Ints.B], Literal[Ints.A])) + + self.assertEqual((Literal[0] | Literal[Ints.A]).__args__, + (Literal[0], Literal[Ints.A])) + self.assertEqual((Literal[1] | Literal[Ints.B]).__args__, + (Literal[1], Literal[Ints.B])) + def test_flatten(self): l1 = Literal[Literal[1], Literal[2], Literal[3]] l2 = Literal[Literal[1, 2], 3] @@ -802,6 +867,20 @@ def test_flatten(self): self.assertEqual(lit, Literal[1, 2, 3]) self.assertEqual(lit.__args__, (1, 2, 3)) + def test_does_not_flatten_enum(self): + import enum + class Ints(enum.IntEnum): + A = 1 + B = 2 + + l = Literal[ + Literal[Ints.A], + Literal[Ints.B], + Literal[1], + Literal[2], + ] + self.assertEqual(l.__args__, (Ints.A, Ints.B, 1, 2)) + def test_caching_of_Literal_respects_type(self): self.assertIs(type(Literal[1].__args__[0]), int) self.assertIs(type(Literal[True].__args__[0]), bool) From e7517099610bb847caab2d096319792f526283cd Mon Sep 17 00:00:00 2001 From: sobolevn Date: Mon, 24 Apr 2023 11:49:10 +0300 Subject: [PATCH 2/4] Fix CI --- src/test_typing_extensions.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index 04a260d0..ace65a78 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -831,7 +831,6 @@ class Ints(enum.IntEnum): (Literal[1], Literal[Ints.B], Literal[True])) def test_or_type_operator_with_Literal(self): - Literal = typing.Literal self.assertEqual((Literal[1] | Literal[2]).__args__, (Literal[1], Literal[2])) From 4731c17d57b7bb96fb337bed2d0f45337441d467 Mon Sep 17 00:00:00 2001 From: sobolevn Date: Mon, 24 Apr 2023 11:49:55 +0300 Subject: [PATCH 3/4] Fix lint --- src/test_typing_extensions.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index ace65a78..24739b5e 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -872,13 +872,13 @@ class Ints(enum.IntEnum): A = 1 B = 2 - l = Literal[ + literal = Literal[ Literal[Ints.A], Literal[Ints.B], Literal[1], Literal[2], ] - self.assertEqual(l.__args__, (Ints.A, Ints.B, 1, 2)) + self.assertEqual(literal.__args__, (Ints.A, Ints.B, 1, 2)) def test_caching_of_Literal_respects_type(self): self.assertIs(type(Literal[1].__args__[0]), int) From b7e377f4a2548b8dedc05a160ddade9f2c777f92 Mon Sep 17 00:00:00 2001 From: sobolevn Date: Mon, 24 Apr 2023 12:01:36 +0300 Subject: [PATCH 4/4] Fix CI --- src/test_typing_extensions.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py index 24739b5e..62e5a4bc 100644 --- a/src/test_typing_extensions.py +++ b/src/test_typing_extensions.py @@ -830,6 +830,7 @@ class Ints(enum.IntEnum): self.assertEqual(Union[Literal[1], Literal[Ints.B], Literal[True]].__args__, (Literal[1], Literal[Ints.B], Literal[True])) + @skipUnless(TYPING_3_10_0, "Python 3.10+ required") def test_or_type_operator_with_Literal(self): self.assertEqual((Literal[1] | Literal[2]).__args__, (Literal[1], Literal[2]))