(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! 👍

Start by reviewing the Template and Interpolation stub definitions in the issue, then read the linked CPython issue and typing-spec discussion about TypeVarTuple transformations. Determine whether the typing specification has a supported workaround or needs a new capability; done means an agreed, implementable way to type both classes.