README claims pep 646 is supported but...the imports don't even seem to exist in Python interpreter

[zzzeek]

Looking at dfa5892, pep 646 variadic generics is claimed to be supported.

But my Python 3.10 interpreter doesn't even seem to support the imports, or the syntax, at all, and pyright doesnt recognize it either.

The program below is taken from https://www.python.org/dev/peps/pep-0646/#type-variable-tuples

from typing import TypeVar, Generic, Tuple, NewType
from typing_extensions import TypeVarTuple

Shape = TypeVarTuple("Shape")

Height = NewType('Height', int)
Width = NewType('Width', int)

class Array(Generic[*Shape]):

    def __init__(self, shape: Tuple[*Shape]):
        self._shape: Tuple[*Shape] = shape

    def get_shape(self) -> Tuple[*Shape]:
        return self._shape

shape = (Height(480), Width(640))
x: Array[Height, Width] = Array(shape)

y = abs(x)  # Inferred type is Array[Height, Width]
z = x + x   #        ...    is Array[Height, Width]

but there's no TypeVarTuple either in "typing" or "typing_extensions":

$ python
Python 3.10.0 (default, Nov  5 2021, 17:23:47) [GCC 11.2.1 20210728 (Red Hat 11.2.1-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import typing
>>> typing.TypeVarTuple
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'typing' has no attribute 'TypeVarTuple'
>>> import typing_extensions
>>> typing_extensions.TypeVarTuple
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'typing_extensions' has no attribute 'TypeVarTuple'

the program doesnt even compile, the syntax is not supported:

$ python test3.py 
  File "/home/classic/dev/sqlalchemy/test3.py", line 9
    class Array(Generic[*Shape]):
               ^
SyntaxError: expected ':'

so...what exactly is the pep-646 support in pyright? within pylance I also see an error like this:

(variable) Shape: Type[Shape@Array]
Unpack operator in subscript is not supportedPylance

if I change it to this:

class Array(Generic[Shape]):

    def __init__(self, shape: Tuple[Shape]):
        self._shape: Tuple[Shape] = shape

then it says the opposite, ha! funny "Expected unpacked TypeVarTuple; use Unpack[Shape] or *ShapePylance"

so...is it like there's some kind of pep-646 mechanism in pyright / pylance but it's basically useless right now? im not understanding why a Python 3 pep has a syntax that the interpreter can't even accept.

[erictraut]

PEP 646 is still in "draft" form. It's open for comment and is being considered for inclusion in Python 3.11. We typically try to get ahead of type-related functionality and incorporate support for them in pyright early. This helps find holes in the standard and gives people a chance to play with the new feature even though it isn't yet implemented in the runtime.

TypeVarTuple and Unpack are not yet defined in the official typeshed stubs, but I include definitions for them in the version of the typing_extensions.pyi stub that ships with pyright and pylance.

The unpack operator in a subscript operator is part of a draft PEP 637 that was rejected for Python 3.10. The authors of PEP 646 are hoping to include the unpack operator within subscript expressions as part of PEP 646, but the Unpack[x] symbol is a backup in case that part of the proposal is rejected by the Python committee.

So, to answer your question, pyright has full type-checking support for the latest draft of PEP 646. You and others can use it to play around with the functionality and provide feedback on the PEP while it's still in the "accepting comments" phase.

[zzzeek]

also is any of this syntax supported? https://www.python.org/dev/peps/pep-0646/#unpacking-unbounded-tuple-types

I'm trying to substitute "Unpack" for "*" in those and it's not working:

    @overload
    def execute(
        self,
        statement: "Select[Unpack[Tuple[_T, ...]]]",
        parameters: Optional[Mapping[str, Any]] = None,
        execution_options: Optional[Mapping[str, Any]] = None,
    ) -> "Result[Unpack[Tuple[_T, ...]]]":
        ...

errors: "Expected TypeVarTuple as type argument for Unpack"

[erictraut]

In an earlier draft of the PEP (the one that I used as the basis for the current pyright implementation), unpacking was allowed only with TypeVarTuple arguments. It appears that in a recent draft, support was added for unpacking tuples. I'll need to add that to my to-do list.

[zzzeek]

OK, I'll leave you alone for now. happy new year!

[mrahtz]

Just to confirm, everything Eric says is correct - PEP 646 is currently still in draft, waiting for approval by the Python steering council.

Unfortunately, yes, it probably will be a while before it's supported by all type checkers. Pyre probably has the best support, and thanks to Eric's hard work Pyright support should also be excellent except for unpacking of tuples.

If you do have any feedback on the PEP while playing around with SQLAlchemy, we would indeed appreciate that feedback very much. https://github.com/mrahtz/cpython/tree/pep646 where we're working on our draft implementation in CPython might also be useful to you.

Happy new year to you both!

[zzzeek]

thanks! I got some POCs working for pep-646 yesterday and the limitation I was coming up against I don't think is intrinsic to pep-646, it's intrinsic to pep-484 in general and I dont think it's going to change.

For background I've illustrated how I (erroneously, I believe) had us design sqlalchemy2-stubs, and how that doesn't really work out even though it seems more correct to me, and we should be instead going with how @JukkaL originally set up typing for column expressions in sqlalchemy-stubs, this is at sqlalchemy/sqlalchemy#7519