fixup! add bound/variance parameters to TypeVarTuple

Author: KotlinIsland

CHANGELOG.md

@@ -13,7 +13,7 @@
   Python 3.9. The `typing` implementation has always raised an error, and the
   `typing_extensions` implementation has raised an error on Python 3.10+ since
   `typing_extensions` v4.6.0. Patch by Brian Schubert.
-- add `bound` and variance parameters to `TypeVarTuple`
+- Add `bound` and variance parameters to `TypeVarTuple`.
 
 # Release 4.15.0 (August 25, 2025)
 

src/test_typing_extensions.py

@@ -1756,11 +1756,9 @@ def test_annotation_and_optional_default(self):
             annotation              : annotation,
             Optional[int]           : Optional[int],
             Optional[List[str]]     : Optional[List[str]],
-            Optional[annotation]     : Optional[annotation],
+            Optional[annotation]    : Optional[annotation],
             Union[str, None, str]   : Optional[str],
             Unpack[Tuple[int, None]]: Unpack[Tuple[int, None]],
-            # Note: A starred *Ts will use typing.Unpack in 3.11+ see Issue #485
-            Unpack[Ts]              : Unpack[Ts],
         }
         # contains a ForwardRef, TypeVar(~prefix) or no expression
         do_not_stringify_cases = {
@@ -1776,6 +1774,8 @@ def test_annotation_and_optional_default(self):
             Union[str, "Union[None, StrAlias]"]: Optional[str],
             Union["annotation", T_default]     : Union[annotation, T_default],
             Annotated["annotation", "nested"]  : Annotated[Union[int, None], "data", "nested"],
+            # Note: A starred *Ts will use typing.Unpack in 3.11+ see Issue #485
+            Unpack[Ts]                         : Unpack[Ts],
         }
         if TYPING_3_10_0:  # cannot construct UnionTypes before 3.10
             do_not_stringify_cases["str | NoneAlias | StrAlias"] = str | None
@@ -6765,8 +6765,9 @@ def test_repr(self):
             self.assertEqual(repr(Ts_contra), '-Ts_contra')
             self.assertEqual(repr(Ts_infer), 'Ts_infer')
         else:
-            # Not worth creating our own version of TypeVarTuple
-            # to backport the repr
+            # On other versions we use typing.TypeVarTuple, but it is not aware of
+            # variance. Not worth creating our own version of TypeVarTuple
+            # for this.
             self.assertEqual(repr(Ts), 'Ts')
             self.assertEqual(repr(Ts_2), 'Ts_2')
 
@@ -7115,6 +7116,10 @@ def test_typing_extensions_defers_when_possible(self):
             exclude |= {
                 'TypeAliasType'
             }
+        if sys.version_info < (3, 15):
+            exclude |= {
+                'TypeVarTuple'
+            }
         if not typing_extensions._PEP_728_IMPLEMENTED:
             exclude |= {'TypedDict', 'is_typeddict'}
         for item in typing_extensions.__all__:

src/typing_extensions.py

@@ -1671,7 +1671,7 @@ def TypeAlias(self, parameters):
 
 def _set_default(type_param, default):
     type_param.has_default = lambda: default is not NoDefault
-    type_param.__default__ = default
+    type_param.__default__ = typing._type_check(default, "Default must be a type.")
 
 
 def _set_module(typevarlike):
@@ -1824,7 +1824,7 @@ def __new__(cls, name, *, bound=None,
                 paramspec = typing.ParamSpec(name, bound=bound,
                                              covariant=covariant,
                                              contravariant=contravariant)
-                paramspec.__infer_variance__ = infer_variance
+                paramspec.__infer_variance__ = bool(infer_variance)
 
             _set_default(paramspec, default)
             _set_module(paramspec)
@@ -2593,10 +2593,10 @@ def __new__(cls, name, *, bound=None,
                 tvt = typing.TypeVarTuple(name)
                 _set_default(tvt, default)
 
-            tvt.__bound__ = bound
-            tvt.__covariant__ = covariant
-            tvt.__contravariant__ = contravariant
-            tvt.__infer_variance__ = infer_variance
+            tvt.__bound__ = typing._type_check(bound, "Bound must be a type.")
+            tvt.__covariant__ = bool(covariant)
+            tvt.__contravariant__ = bool(contravariant)
+            tvt.__infer_variance__ = bool(infer_variance)
 
             _set_module(tvt)