Better arangement and style

Author: Daraan

src/test_typing_extensions.py

@@ -5307,6 +5307,7 @@ class ProtoZ(Protocol[P]):
                 G6 = klass[int, str, T]
                 G6args = G6.__args__[0] if sys.version_info >= (3, 10) else G6.__args__
                 self.assertEqual(G6args, (int, str, T))
+                self.assertEqual(G6.__parameters__, (T,))
 
                 # P = [int]
                 G7 = klass[int]
@@ -5340,61 +5341,54 @@ class ProtoZ(Protocol[P]):
         things = "arguments" if sys.version_info >= (3, 10) else "parameters"
         for klass in Z, ProtoZ:
             with self.subTest(klass=klass.__name__):
-                G6 = klass[int, str, T]
                 G8 = klass[Concatenate[T, ...]]
+
+                H8_1 = G8[int]
+                self.assertEqual(H8_1.__parameters__, ())
+                with self.assertRaisesRegex(TypeError, "not a generic class"):
+                    H8_1[str]
+
+                H8_2 = G8[T][int]
+                self.assertEqual(H8_2.__parameters__, ())
+                with self.assertRaisesRegex(TypeError, "not a generic class"):
+                    H8_2[str]
+
                 G9 = klass[Concatenate[T, P_2]]
+                self.assertEqual(G9.__parameters__, (T, P_2))
 
                 with self.assertRaisesRegex(TypeError,
-                        (
-                            "The last parameter to Concatenate should be a ParamSpec variable or ellipsis."
-                            if sys.version_info < (3, 10) else
-                            # from __typing_subst__
-                        "Expected a list of types, an ellipsis, ParamSpec, or Concatenate"
-                        )
+                    "The last parameter to Concatenate should be a ParamSpec variable or ellipsis."
+                    if sys.version_info < (3, 10) else
+                    # from __typing_subst__
+                    "Expected a list of types, an ellipsis, ParamSpec, or Concatenate"
                 ):
                     G9[int, int]
 
-                self.assertEqual(G9.__parameters__, (T, P_2))
                 with self.assertRaisesRegex(TypeError, f"Too few {things}"):
                     G9[int]
 
                 with self.subTest("Check list as parameter expression", klass=klass.__name__):
                     if sys.version_info < (3, 10):
                         self.skipTest("Cannot pass non-types")
                     G5 = klass[[int, str, T]]
+                    self.assertEqual(G5.__parameters__, (T,))
                     self.assertEqual(G5.__args__, ((int, str, T),))
-                    H9 = G9[int, [T]]
-
-
-                with self.subTest("Check parametrization", klass=klass.__name__):
-                    if sys.version_info >= (3, 10):  # only availiable for 3.10+
-                        self.assertEqual(H9.__parameters__, (T,))
-                        self.assertEqual(G5.__parameters__, (T,))
-                    self.assertEqual(G6.__parameters__, (T,))
 
-                with self.subTest("Check further substitution", klass=klass.__name__):
-                    H1 = G8[int]
-                    self.assertEqual(H1.__parameters__, ())
-                    with self.assertRaisesRegex(TypeError, "not a generic class"):
-                        H1[str]
-
-                    H2 = G8[T][int]
-                    self.assertEqual(H2.__parameters__, ())
-                    with self.assertRaisesRegex(TypeError, "not a generic class"):
-                        H2[str]
+                    H9 = G9[int, [T]]
+                    self.assertEqual(H9.__parameters__, (T,))
 
                 # This is an invalid parameter expression but useful for testing correct subsitution
                 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")
-                    H3 = G10[int]
+                    H10 = G10[int]
                     if (3, 10) <= sys.version_info < (3, 11, 3):
                         self.skipTest("3.10-3.11.2 does not substitute Concatenate here")
-                    self.assertEqual(H3.__parameters__, ())
-                    H3args = H3.__args__[0] if sys.version_info >= (3, 10) else H3.__args__
-                    self.assertEqual(H3args, (int, (str, int)))
+                    self.assertEqual(H10.__parameters__, ())
+                    H10args = H10.__args__[0] if sys.version_info >= (3, 10) else H10.__args__
+                    self.assertEqual(H10args, (int, (str, int)))
 
     def test_pickle(self):
         global P, P_co, P_contra, P_default

src/typing_extensions.py

@@ -1820,7 +1820,7 @@ def copy_with(self, params):
                 params = (*params[:-1], *params[-1].__args__)
             elif isinstance(params[-1], (list, tuple)):
                 return (*params[:-1], *params[-1])
-            elif (not(params[-1] is ... or isinstance(params[-1], ParamSpec))):
+            elif (not (params[-1] is ... or isinstance(params[-1], ParamSpec))):
                 raise TypeError("The last parameter to Concatenate should be a "
                         "ParamSpec variable or ellipsis.")
             return self.__class__(self.__origin__, params)
@@ -1861,7 +1861,7 @@ def __getitem__(self, args):
                         # This class inherits from list do not convert
                         and not isinstance(args[i], _ConcatenateGenericAlias)
                     ):
-                        args = (*args[:i], tuple(args[i]), *args[i+1:])
+                        args = (*args[:i], tuple(args[i]), *args[i + 1:])
 
             alen = len(args)
             plen = len(params)
@@ -2657,6 +2657,7 @@ def _unpack_args(*args):
             newargs.append(arg)
     return newargs
 
+
 if _PEP_696_IMPLEMENTED:
     from typing import TypeVarTuple
 
@@ -3134,11 +3135,13 @@ def wrapper(*args, **kwargs):
                     f"a class or callable, not {arg!r}"
                 )
 
+
 def _is_param_expr(arg):
     return arg is ... or isinstance(
         arg, (tuple, list, ParamSpec, _ConcatenateGenericAlias)
     )
 
+
 # We have to do some monkey patching to deal with the dual nature of
 # Unpack/TypeVarTuple:
 # - We want Unpack to be a kind of TypeVar so it gets accepted in