Update repr output of t-strings to resemble to t-string's source, but include the interpolated values.

Author: doerwalter

Doc/library/string.templatelib.rst

@@ -33,10 +33,7 @@ To write a t-string, use a ``'t'`` prefix instead of an ``'f'``, like so:
 
    >>> pi = 3.14
    >>> t't-strings are new in Python {pi!s}!'
-   Template(
-      strings=('t-strings are new in Python ', '!'),
-      interpolations=(Interpolation(3.14, 'pi', 's', ''),)
-   )
+   <Template t't-strings are new in Python {pi!s=3.14}!' at 0x...>
 
 Types
 -----
@@ -118,7 +115,7 @@ Types
       >>> cheese = 'Camembert'
       >>> template = t'Ah! We do have {cheese}.'
       >>> template.interpolations
-      (Interpolation('Camembert', 'cheese', None, ''),)
+      (Interpolation('Camembert', 'cheese'),)
 
       The ``interpolations`` tuple may be empty and always contains one fewer
       values than the ``strings`` tuple:
@@ -153,7 +150,7 @@ Types
       ...     'Ah! We do have ', Interpolation(cheese, 'cheese'), '.'
       ... )
       >>> list(template)
-      ['Ah! We do have ', Interpolation('Camembert', 'cheese', None, ''), '.']
+      ['Ah! We do have ', Interpolation('Camembert', 'cheese'), '.']
 
       If multiple strings are passed consecutively, they will be concatenated
       into a single value in the :attr:`~Template.strings` attribute. For example,
@@ -184,7 +181,7 @@ Types
 
       >>> cheese = 'Camembert'
       >>> list(t'Ah! We do have {cheese}.')
-      ['Ah! We do have ', Interpolation('Camembert', 'cheese', None, ''), '.']
+      ['Ah! We do have ', Interpolation('Camembert', 'cheese'), '.']
 
       .. caution::
 
@@ -194,8 +191,8 @@ Types
          >>> cheese = 'Camembert'
          >>> list(t'Ah! {response}{cheese}.')  # doctest: +NORMALIZE_WHITESPACE
          ['Ah! ',
-          Interpolation('We do have ', 'response', None, ''),
-          Interpolation('Camembert', 'cheese', None, ''),
+          Interpolation('We do have ', 'response'),
+          Interpolation('Camembert', 'cheese'),
           '.']
 
    .. describe:: template + other
@@ -206,7 +203,7 @@ Types
 
       >>> cheese = 'Camembert'
       >>> list(t'Ah! ' + t'We do have {cheese}.')
-      ['Ah! We do have ', Interpolation('Camembert', 'cheese', None, ''), '.']
+      ['Ah! We do have ', Interpolation('Camembert', 'cheese'), '.']
 
       Concatenating a :class:`!Template` and a ``str`` is **not** supported.
       This is because it is unclear whether the string should be treated as
@@ -224,7 +221,7 @@ Types
       >>> cheese = 'Camembert'
       >>> template += Template(Interpolation(cheese, 'cheese'))
       >>> list(template)
-      ['Ah! We do have ', Interpolation('Camembert', 'cheese', None, '')]
+      ['Ah! We do have ', Interpolation('Camembert', 'cheese')]
 
 
 .. class:: Interpolation

Doc/reference/expressions.rst

@@ -318,7 +318,7 @@ Also, template string literals may only be combined with other template
 string literals::
 
    >>> t"Hello" t"{name}!"
-   Template(strings=('Hello', '!'), interpolations=(...))
+   <Template t'Hello{name='Blaise'}!' at 0x...>
 
 Formally:
 

Include/internal/pycore_interpolation.h

@@ -18,6 +18,8 @@ PyAPI_FUNC(PyObject *) _PyInterpolation_Build(PyObject *value, PyObject *str,
 
 extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp);
 extern PyObject *_PyInterpolation_GetValueRef(PyObject *interpolation);
+extern int _PyInterpolation_WriteSource(PyUnicodeWriter *writer,
+                                        PyObject *interpolation);
 
 #ifdef __cplusplus
 }

Lib/pprint.py

@@ -785,8 +785,11 @@ def _pprint_interpolation(self, object, stream, indent, allowance, context, leve
             stream.write(")")
 
     t = t"{0}"
-    _dispatch[type(t).__repr__] = _pprint_template
-    _dispatch[type(t.interpolations[0]).__repr__] = _pprint_interpolation
+    _template = type(t)
+    _dispatch[_template.__repr__] = _pprint_template
+
+    _interpolation = type(t.interpolations[0])
+    _dispatch[_interpolation.__repr__] = _pprint_interpolation
     del t
 
     def _safe_repr(self, object, context, maxlevels, level):
@@ -915,6 +918,42 @@ def _safe_repr(self, object, context, maxlevels, level):
             del context[objid]
             return typ.__name__ + '([%s])' % ", ".join(components), readable, recursive
 
+        if (issubclass(typ, self._template) and r is self._template.__repr__) or \
+           (issubclass(typ, self._interpolation) and r is self._interpolation.__repr__):
+            # Don't use the repr of templates and interpolations, since the repr
+            # of a template resembles its source code (and includes the id of
+            # the template). Use constructor syntax instead, which is what
+            # _pprint_template and _pprint_interpolation produce as well.
+            objid = id(object)
+            if maxlevels and level >= maxlevels:
+                return f"{typ.__name__}(...)", False, objid in context
+            if objid in context:
+                return _recursion(object), False, True
+            if typ is self._template:
+                items = object
+            else:
+                items = (object.value, object.expression)
+                if object.conversion is not None or object.format_spec:
+                    items += (object.conversion,)
+                    if object.format_spec:
+                        items += (object.format_spec,)
+            context[objid] = 1
+            readable = True
+            recursive = False
+            components = []
+            append = components.append
+            level += 1
+            for item in items:
+                irepr, ireadable, irecur = self.format(
+                    item, context, maxlevels, level)
+                append(irepr)
+                readable = readable and ireadable
+                if irecur:
+                    recursive = True
+            del context[objid]
+            rep = "%s(%s)" % (typ.__name__, ", ".join(components))
+            return rep, readable, recursive
+
         rep = repr(object)
         return rep, (rep and not rep.startswith('<')), False
 

Lib/test/test_pprint.py

@@ -1517,14 +1517,27 @@ def test_user_string(self):
 
     def test_template(self):
         d = t""
+        # Templates are always printed using constructor syntax, i.e. the
+        # "<Template ...>" format of repr() is never used
         self.assertEqual(pprint.pformat(d), "Template()")
-        self.assertEqual(pprint.pformat(d), repr(d))
+        self.assertNotEqual(pprint.pformat(d), repr(d))
         self.assertEqual(pprint.pformat(d, width=1), "Template()")
         name = "World"
         d = t"Hello {name}"
         self.assertEqual(pprint.pformat(d),
 """\
 Template('Hello ', Interpolation('World', 'name'))""")
+        # This is also true for templates nested inside other objects and for
+        # saferepr()
+        self.assertEqual(pprint.pformat({'greeting': d}),
+"""\
+{'greeting': Template('Hello ', Interpolation('World', 'name'))}""")
+        self.assertEqual(pprint.saferepr(d),
+"""\
+Template('Hello ', Interpolation('World', 'name'))""")
+        self.assertEqual(pprint.saferepr(d.interpolations[0]),
+"""\
+Interpolation('World', 'name')""")
         d = t"Hello {name!r}"
         self.assertEqual(pprint.pformat(d),
 """\

Lib/test/test_string/test_templatelib.py

@@ -1,4 +1,5 @@
 import pickle
+import re
 import unittest
 from collections.abc import Iterator, Iterable
 from string.templatelib import Template, Interpolation, convert
@@ -101,32 +102,45 @@ def test_template_values(self):
         t = t'Hello, {name}, {age} from {country}'
         self.assertEqual(t.values, ("Lys", 0, "GR"))
 
+    def check_repr(self, template, source):
+        """
+        Check that the repr of 'template' consists of the class name, 'source'
+        (the source-like part of the repr, including the 't' prefix and the
+        quotes) and the id of the template.
+        """
+        self.assertRegex(
+            repr(template),
+            rf'^<Template {re.escape(source)} at 0x[0-9A-Fa-f]+>$')
+
     def test_repr(self):
-        self.assertEqual(repr(t''), 'Template()')
-        self.assertEqual(repr(t'foo'), "Template('foo')")
+        self.check_repr(t'', """t''""")
+        self.check_repr(t'foo', """t'foo'""")
 
         # Test various combination for present/absent conversion and format_spec
         x = 42
-        self.assertEqual(
-            repr(t'{x}'),
-            "Template(Interpolation(42, 'x'))")
-        self.assertEqual(
-            repr(t'{x!r}'),
-            "Template(Interpolation(42, 'x', 'r'))")
-        self.assertEqual(
-            repr(t'{x:02}'),
-            "Template(Interpolation(42, 'x', None, '02'))")
-        self.assertEqual(
-            repr(t'a{x!r:02}b'),
-            "Template('a', Interpolation(42, 'x', 'r', '02'), 'b')")
+        self.check_repr(t'{x}', """t'{x=42}'""")
+        self.check_repr(t'{x!r}', """t'{x!r=42}'""")
+        self.check_repr(t'{x:02}', """t'{x:02=42}'""")
+        self.check_repr(t'a{x!r:02}b', """t'a{x!r:02=42}b'""")
+
+        # Braces in the literal parts have to be doubled
+        self.check_repr(t'{{a}}{x}', """t'{{a}}{x=42}'""")
+
+        # The literal parts are escaped like in a string repr, and the quote
+        # is chosen the same way
+        self.check_repr(t'a\n{x}', """t'a\\n{x=42}'""")
+        self.check_repr(t'"a"{x}', """t'"a"{x=42}'""")
+        self.check_repr(t"'a'{x}", '''t"'a'{x=42}"''')
+        self.check_repr(t'\'a\'"b"{x}', """t'\\'a\\'"b"{x=42}'""")
 
         # Test a "recursive" template
         x = []
         t = t'a{x}b'
         x.append(t)
-        self.assertEqual(
+        self.assertRegex(
             repr(t),
-            "Template('a', Interpolation([Template(...)], 'x'), 'b')")
+            r"^<Template t'a\{x=\[<Template \.\.\. at 0x[0-9A-Fa-f]+>\]\}b' "
+            r"at 0x[0-9A-Fa-f]+>$")
 
     def test_pickle_template(self):
         user = 'test'

Lib/test/test_tstring.py

@@ -7,13 +7,12 @@ class TestTString(unittest.TestCase, TStringBaseCase):
     def test_string_representation(self):
         # Test __repr__
         t = t"Hello"
-        self.assertEqual(repr(t), "Template(strings=('Hello',), interpolations=())")
+        self.assertRegex(repr(t), r"^<Template t'Hello' at 0x[0-9A-Fa-f]+>$")
 
         name = "Python"
         t = t"Hello, {name}"
-        self.assertEqual(repr(t),
-            "Template(strings=('Hello, ', ''), "
-            "interpolations=(Interpolation('Python', 'name', None, ''),))"
+        self.assertRegex(repr(t),
+            r"^<Template t'Hello, \{name='Python'\}' at 0x[0-9A-Fa-f]+>$"
         )
 
     def test_interpolation_basics(self):

Misc/NEWS.d/next/Library/2026-06-08-20-38-28.gh-issue-151099.6Opls1.rst

@@ -1,2 +1,3 @@
-Change :func:`repr` output of :class:`string.templatelib.Template` objects
-to list the parts of the template in their original source order.
+Change :func:`repr` output of :class:`string.templatelib.Template` objects to
+resemble the source code the template was created from, additionally including
+the value of each interpolation.

Objects/interpolationobject.c

@@ -139,6 +139,46 @@ interpolation_repr(PyObject *op)
     }
 }
 
+/* Write a representation of the interpolation that resembles the source code
+   it was created from, i.e. the expression, the conversion and the format spec
+   (if they are non-default), followed by "=" and the repr of the value, all
+   enclosed in braces. This is used by the repr of Template. */
+int
+_PyInterpolation_WriteSource(PyUnicodeWriter *writer, PyObject *op)
+{
+    interpolationobject *self = interpolationobject_CAST(op);
+
+    if (PyUnicodeWriter_WriteChar(writer, '{') < 0) {
+        return -1;
+    }
+    if (PyUnicodeWriter_WriteStr(writer, self->expression) < 0) {
+        return -1;
+    }
+    if (self->conversion != Py_None) {
+        if (PyUnicodeWriter_WriteChar(writer, '!') < 0) {
+            return -1;
+        }
+        if (PyUnicodeWriter_WriteStr(writer, self->conversion) < 0) {
+            return -1;
+        }
+    }
+    if (PyUnicode_GET_LENGTH(self->format_spec) > 0) {
+        if (PyUnicodeWriter_WriteChar(writer, ':') < 0) {
+            return -1;
+        }
+        if (PyUnicodeWriter_WriteStr(writer, self->format_spec) < 0) {
+            return -1;
+        }
+    }
+    if (PyUnicodeWriter_WriteChar(writer, '=') < 0) {
+        return -1;
+    }
+    if (PyUnicodeWriter_WriteRepr(writer, self->value) < 0) {
+        return -1;
+    }
+    return PyUnicodeWriter_WriteChar(writer, '}');
+}
+
 static PyMemberDef interpolation_members[] = {
     {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"},
     {"expression", Py_T_OBJECT_EX, offsetof(interpolationobject, expression), Py_READONLY, "Expression"},