(3.14) Templates not typeable without TypeVarTuple transformations

I recently tried to create my own stubs for Python 3.14's Template and Interpolation types, but it seems that is currently not possible. I waited a while and searched a lot and did not find anybody talk about this issue anywhere.

Their runtime generic-ness was recently added:
https://github.com/python/cpython/issues/133970

But it seems that it is not currently possible to actually type hint them correctly within the current typing spec, because transformations of the TypeVarTuple would be necessary. (https://github.com/python/typing/issues/1216)

Currently the code for those two classes' typing stubs looks like this:

class Template:  # TODO: consider making `Template` generic on `TypeVarTuple`
    strings: tuple[str, ...]
    interpolations: tuple[Interpolation, ...]

    def __new__(cls, *args: str | Interpolation) -> Template: ...
    def __iter__(self) -> Iterator[str | Interpolation]: ...
    def __add__(self, other: Template, /) -> Template: ...
    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
    @property
    def values(self) -> tuple[Any, ...]: ...  # Tuple of interpolation values, which can have any type

@final
class Interpolation:
    value: Any  # TODO: consider making `Interpolation` generic in runtime
    expression: str
    conversion: Literal["a", "r", "s"] | None
    format_spec: str

    __match_args__ = ("value", "expression", "conversion", "format_spec")

    def __new__(
        cls, value: Any, expression: str = "", conversion: Literal["a", "r", "s"] | None = None, format_spec: str = ""
    ) -> Interpolation: ...
    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

And it would need to be updated to something like this (using newer syntax for this example):

from types import GenericAlias
from typing import Any, final, Iterator, Literal

class Template[*Ts]:
    strings: tuple[str, ...]
    interpolations: tuple[Interpolation[Ts], ...]  # Not possible to map/transform onto interpolations

    def __new__(cls, *args: str | Interpolation[Ts]) -> Template: ...  # Not possible to map/transform onto interpolations
    def __iter__(self) -> Iterator[str | Interpolation[Ts]]: ...  # Not possible to map/transform onto interpolations
    def __add__[*OtherTs](self, other: Template[*OtherTs], /) -> Template[*Ts, *OtherTs]: ...
    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
    @property
    def values(self) -> tuple[*Ts]: ...

@final
class Interpolation[T]:
    value: T
    expression: str
    conversion: Literal["a", "r", "s"] | None
    format_spec: str

    __match_args__ = ("value", "expression", "conversion", "format_spec")

    def __new__(
        cls, value: T, expression: str = "", conversion: Literal["a", "r", "s"] | None = None, format_spec: str = ""
    ) -> Interpolation[T]: ...
    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

So basically we would need to map the TypeVarTuple's elements into each Interpolation, which is currently not possible.

So it looks like typing Templates and Interpolations is not possible until transformations get added. If I missed something or there is a workaround, please inform me! Thank you! 👍

Empieza revisando las definiciones stub de Template e Interpolation en el issue y, después, lee el issue de CPython enlazado y el debate de typing-spec sobre las transformaciones de TypeVarTuple. Determina si la especificación de typing tiene una solución alternativa compatible o si necesita una nueva capacidad; se considera terminado cuando exista una forma acordada e implementable de tipar ambas clases.