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

Beginne damit, die Stub-Definitionen von Template und Interpolation im Issue zu prüfen, und lies anschließend das verknüpfte CPython-Issue sowie die typing-spec-Diskussion über Transformationen von TypeVarTuple. Ermittle, ob die Typing-Spezifikation einen unterstützten Workaround bietet oder eine neue Fähigkeit benötigt; abgeschlossen ist die Aufgabe, wenn es eine vereinbarte, implementierbare Möglichkeit gibt, beide Klassen zu typisieren.