Jun 12, 2022 · May 29, 2022 · May 29, 2022 · May 29, 2022 · May 30, 2022 · May 31, 2022
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
            ('generic[*Ts]',                           '[*tuple_type[int]]',                             'generic[int]'),
            ('generic[*Ts]',                           '[*tuple_type[*Ts]]',                             'generic[*Ts]'),
            ('generic[*Ts]',                           '[*tuple_type[int, str]]',                        'generic[int, str]'),
            ('generic[*Ts]',                           '[str, *tuple_type[int, ...], bool]',             'generic[str, *tuple_type[int, ...], bool]'),
            ('generic[*Ts]',                           '[tuple_type[int, ...]]',                         'generic[tuple_type[int, ...]]'),
            ('generic[*Ts]',                           '[tuple_type[int, ...], tuple_type[str, ...]]',   'generic[tuple_type[int, ...], tuple_type[str, ...]]'),
            ('generic[*Ts]',                           '[*tuple_type[int, ...]]',                        'generic[*tuple_type[int, ...]]'),
            ('generic[*Ts]',                           '[str,*tuple_type[int, ...],bool]',             'generic[str,*tuple_type[int, ...], bool]'),
            ('generic[*Ts]',                           '[*tuple_type[int, ...], *tuple_type[str, ...]]', 'TypeError'),

            ('generic[*Ts]',                           '[*Ts]',                                          'generic[*Ts]'),
            ('generic[*Ts]',                           '[T, *Ts]',                                       'generic[T, *Ts]'),
diff --git a/Lib/typing.py b/Lib/typing.py
    return ((not isinstance(x, type)) and
            getattr(x, '__typing_is_unpacked_typevartuple__', False))

 def _is_unpacked_var_tuple(x: Any) -> bool:
    if isinstance(x, type) and not isinstance(x, GenericAlias):
        return False
    args = getattr(x, '__typing_unpacked_tuple_args__', None)
    if args and args[-1] is ...:
        return True
    return False


 def _is_typevar_like(x: Any) -> bool:
    return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x)
                + [attr for attr in dir(self.__origin__) if not _is_dunder(attr)]))


 def _is_unpacked_tuple(x: Any) -> bool:
    # Is `x` something like `*tuple[int]` or `*tuple[int, ...]`?
    if not isinstance(x, _UnpackGenericAlias):
        return False
    # Alright, `x` is `Unpack[something]`.

    # `x` will always have `__args__`, because Unpack[] and Unpack[()]
    # aren't legal.
    unpacked_type = x.__args__[0]

    return getattr(unpacked_type, '__origin__', None) is tuple


 def _is_unpacked_arbitrary_length_tuple(x: Any) -> bool:
    if not _is_unpacked_tuple(x):
        return False
    unpacked_tuple = x.__args__[0]

    if not hasattr(unpacked_tuple, '__args__'):
        # It's `Unpack[tuple]`. We can't make any assumptions about the length
        # of the tuple, so it's effectively an arbitrary-length tuple.
        return True

    tuple_args = unpacked_tuple.__args__
    if not tuple_args:
        # It's `Unpack[tuple[()]]`.
        return False

    last_arg = tuple_args[-1]
    if last_arg is Ellipsis:
        # It's `Unpack[tuple[something, ...]]`, which is arbitrary-length.
        return True

    # If the arguments didn't end with an ellipsis, then it's not an
    # arbitrary-length tuple.
    return False


 # Special typing constructs Union, Optional, Generic, Callable and Tuple
 # use three special attributes for internal bookkeeping of generic types:
 # * __parameters__ is a tuple of unique free type parameters of a generic
            right = plen - typevartuple_index - 1
            var_tuple_index = None
            for k, arg in enumerate(args):
                if _is_unpacked_var_tuple(arg):
                    if var_tuple_index is not None:
                        raise TypeError("More than one unpacked variable-size tuple argument")
                    var_tuple_index = k
                    fillarg = args[var_tuple_index].__typing_unpacked_tuple_args__[0]
                if not (isinstance(arg, type) and not isinstance(arg, GenericAlias)):
                    subargs = getattr(arg, '__typing_unpacked_tuple_args__', None)
                    if subargs and len(subargs) == 2 and subargs[-1] is ...:
                        if var_tuple_index is not None:
                            raise TypeError("More than one unpacked arbitrary-length tuple argument")
                        var_tuple_index = k
                        fillarg = subargs[0]
            if var_tuple_index is not None:
                left = min(left, var_tuple_index)
                right = min(right, alen - var_tuple_index - 1)
diff --git a/Objects/genericaliasobject.c b/Objects/genericaliasobject.c
                    Py_DECREF(fillarg);
                    Py_DECREF(item);
                    return PyErr_Format(PyExc_TypeError,
                                        "More than one unpackedvariable-size tuple argument",
                                        "More than one unpackedarbitrary-length tuple argument",
                                        self);
                }
                vartuplearg = i;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -753,10 +753,11 @@ class C(Generic[*Ts]): pass
		('generic[Ts]', '[tuple_type[int]]', 'generic[int]'),
		('generic[Ts]', '[tuple_type[Ts]]', 'generic[Ts]'),
		('generic[Ts]', '[tuple_type[int, str]]', 'generic[int, str]'),
		('generic[Ts]', '[str, tuple_type[int, ...], bool]', 'generic[str, *tuple_type[int, ...], bool]'),
		('generic[*Ts]', '[tuple_type[int, ...]]', 'generic[tuple_type[int, ...]]'),
		('generic[*Ts]', '[tuple_type[int, ...], tuple_type[str, ...]]', 'generic[tuple_type[int, ...], tuple_type[str, ...]]'),
		('generic[Ts]', '[tuple_type[int, ...]]', 'generic[*tuple_type[int, ...]]'),
		('generic[Ts]', '[str,tuple_type[int, ...],bool]', 'generic[str,*tuple_type[int, ...], bool]'),
		('generic[Ts]', '[tuple_type[int, ...], *tuple_type[str, ...]]', 'TypeError'),

		('generic[Ts]', '[Ts]', 'generic[*Ts]'),
		('generic[Ts]', '[T, Ts]', 'generic[T, *Ts]'),
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -906,14 +906,6 @@ def _is_unpacked_typevartuple(x: Any) -> bool:
		return ((not isinstance(x, type)) and
		getattr(x, '__typing_is_unpacked_typevartuple__', False))

		def _is_unpacked_var_tuple(x: Any) -> bool:
		if isinstance(x, type) and not isinstance(x, GenericAlias):
		return False
		args = getattr(x, '__typing_unpacked_tuple_args__', None)
		if args and args[-1] is ...:
		return True
		return False


		def _is_typevar_like(x: Any) -> bool:
		return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x)
Expand DownExpand Up		@@ -1263,44 +1255,6 @@ def __dir__(self):
		+ [attr for attr in dir(self.__origin__) if not _is_dunder(attr)]))


		def _is_unpacked_tuple(x: Any) -> bool:
		# Is `x` something like `tuple[int]` or `tuple[int, ...]`?
		if not isinstance(x, _UnpackGenericAlias):
		return False
		# Alright, `x` is `Unpack[something]`.

		# `x` will always have `__args__`, because Unpack[] and Unpack[()]
		# aren't legal.
		unpacked_type = x.__args__[0]

		return getattr(unpacked_type, '__origin__', None) is tuple


		def _is_unpacked_arbitrary_length_tuple(x: Any) -> bool:
		if not _is_unpacked_tuple(x):
		return False
		unpacked_tuple = x.__args__[0]

		if not hasattr(unpacked_tuple, '__args__'):
		# It's `Unpack[tuple]`. We can't make any assumptions about the length
		# of the tuple, so it's effectively an arbitrary-length tuple.
		return True

		tuple_args = unpacked_tuple.__args__
		if not tuple_args:
		# It's `Unpack[tuple[()]]`.
		return False

		last_arg = tuple_args[-1]
		if last_arg is Ellipsis:
		# It's `Unpack[tuple[something, ...]]`, which is arbitrary-length.
		return True

		# If the arguments didn't end with an ellipsis, then it's not an
		# arbitrary-length tuple.
		return False


		# Special typing constructs Union, Optional, Generic, Callable and Tuple
		# use three special attributes for internal bookkeeping of generic types:
		# * __parameters__ is a tuple of unique free type parameters of a generic
Expand DownExpand Up		@@ -1433,11 +1387,13 @@ def _determine_new_args(self, args):
		right = plen - typevartuple_index - 1
		var_tuple_index = None
		for k, arg in enumerate(args):
		if _is_unpacked_var_tuple(arg):
		if var_tuple_index is not None:
		raise TypeError("More than one unpacked variable-size tuple argument")
		var_tuple_index = k
		fillarg = args[var_tuple_index].__typing_unpacked_tuple_args__[0]
		if not (isinstance(arg, type) and not isinstance(arg, GenericAlias)):
		subargs = getattr(arg, '__typing_unpacked_tuple_args__', None)
		if subargs and len(subargs) == 2 and subargs[-1] is ...:
		if var_tuple_index is not None:
		raise TypeError("More than one unpacked arbitrary-length tuple argument")
		var_tuple_index = k
		fillarg = subargs[0]
		if var_tuple_index is not None:
		left = min(left, var_tuple_index)
		right = min(right, alen - var_tuple_index - 1)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -469,7 +469,7 @@ _Py_subs_parameters(PyObject self, PyObject args, PyObject *parameters, PyObje
		Py_DECREF(fillarg);
		Py_DECREF(item);
		return PyErr_Format(PyExc_TypeError,
		"More than one unpackedvariable-size tuple argument",
		"More than one unpackedarbitrary-length tuple argument",
		self);
		}
		vartuplearg = i;
Expand Down