TemplateStr

dflook · dflook · commit 8d9c29416f94 · 2025-08-20T11:35:24.000+01:00
diff --git a/src/python_minifier/expression_printer.py b/src/python_minifier/expression_printer.py
@@ -743,6 +743,13 @@ def visit_JoinedStr(self, node):
 
         self.printer.fstring(str(python_minifier.f_string.OuterFString(node, pep701=pep701)))
 
+    def visit_TemplateStr(self, node):
+        assert isinstance(node, ast.TemplateStr)
+
+        import python_minifier.t_string
+
+        self.printer.tstring(str(python_minifier.t_string.TString(node)))
+
     def visit_NamedExpr(self, node):
         self._expression(node.target)
         self.printer.operator(':=')
diff --git a/src/python_minifier/t_string.py b/src/python_minifier/t_string.py
@@ -0,0 +1,292 @@
+"""
+Template String (T-String) unparsing
+
+T-strings in Python 3.14 follow PEP 750 and are based on PEP 701,
+which means they don't have the quote restrictions of older f-strings.
+
+This implementation is much simpler than f_string.py because:
+- No quote tracking needed (PEP 701 benefits)
+- No pep701 parameter needed (always true for t-strings)
+- No Outer vs Inner distinction needed
+- Always use all quote types
+"""
+
+import python_minifier.ast_compat as ast
+
+from python_minifier import UnstableMinification
+from python_minifier.ast_compare import CompareError, compare_ast
+from python_minifier.expression_printer import ExpressionPrinter
+from python_minifier.ministring import MiniString
+from python_minifier.token_printer import TokenTypes
+from python_minifier.util import is_constant_node
+
+
+class TString(object):
+    """
+    A Template String (t-string)
+
+    Much simpler than f-strings because PEP 701 eliminates quote restrictions
+    """
+
+    def __init__(self, node):
+        assert isinstance(node, ast.TemplateStr)
+        self.node = node
+        # Always use all quotes - no restrictions due to PEP 701
+        self.allowed_quotes = ['"', "'", '"""', "'''"]
+
+    def is_correct_ast(self, code):
+        """Check if the generated code produces the same AST"""
+        try:
+            c = ast.parse(code, 'TString candidate', mode='eval')
+            compare_ast(self.node, c.body)
+            return True
+        except Exception:
+            return False
+
+    def complete_debug_specifier(self, partial_specifier_candidates, value_node):
+        """Complete debug specifier candidates for an Interpolation node"""
+        assert isinstance(value_node, ast.Interpolation)
+
+        conversion = ''
+        if value_node.conversion == 115:  # 's'
+            conversion = '!s'
+        elif value_node.conversion == 114 and value_node.format_spec is not None:
+            # This is the default for debug specifiers, unless there's a format_spec
+            conversion = '!r'
+        elif value_node.conversion == 97:  # 'a'
+            conversion = '!a'
+
+        conversion_candidates = [x + conversion for x in partial_specifier_candidates]
+
+        if value_node.format_spec is not None:
+            # Handle format specifications in debug specifiers
+            if isinstance(value_node.format_spec, ast.JoinedStr):
+                import python_minifier.f_string
+                format_specs = python_minifier.f_string.FormatSpec(value_node.format_spec, self.allowed_quotes, pep701=True).candidates()
+                conversion_candidates = [c + ':' + fs for c in conversion_candidates for fs in format_specs]
+
+        return [x + '}' for x in conversion_candidates]
+
+    def candidates(self):
+        """Generate all possible representations"""
+        actual_candidates = []
+
+        for quote in self.allowed_quotes:
+            candidates = ['']
+            debug_specifier_candidates = []
+
+            for v in self.node.values:
+                if is_constant_node(v, ast.Constant) and isinstance(v.value, str):
+                    # String literal part - check for debug specifiers
+
+                    # Could this be used as a debug specifier?
+                    if len(candidates) < 10:
+                        import re
+                        debug_specifier = re.match(r'.*=\s*$', v.value)
+                        if debug_specifier:
+                            # Maybe! Save for potential debug specifier completion
+                            try:
+                                debug_specifier_candidates = [x + '{' + v.value for x in candidates]
+                            except Exception:
+                                continue
+
+                    try:
+                        candidates = [x + self.str_for(v.value, quote) for x in candidates]
+                    except Exception:
+                        continue
+
+                elif isinstance(v, ast.Interpolation):
+                    # Interpolated expression part - check for debug completion
+                    try:
+                        # Try debug specifier completion
+                        completed = self.complete_debug_specifier(debug_specifier_candidates, v)
+
+                        # Regular interpolation processing
+                        interpolation_candidates = InterpolationValue(v).get_candidates()
+                        candidates = [x + y for x in candidates for y in interpolation_candidates] + completed
+
+                        debug_specifier_candidates = []
+                    except Exception:
+                        continue
+                else:
+                    raise RuntimeError('Unexpected TemplateStr value: %r' % v)
+
+            actual_candidates.extend(['t' + quote + x + quote for x in candidates])
+
+        return filter(self.is_correct_ast, actual_candidates)
+
+    def str_for(self, s, quote):
+        """Convert string literal to properly escaped form"""
+        # Use MiniString for optimal string representation
+        # Always allowed due to PEP 701 - no backslash restrictions
+        mini_s = str(MiniString(s, quote)).replace('{', '{{').replace('}', '}}')
+
+        if mini_s == '':
+            return '\\\n'
+        return mini_s
+
+    def __str__(self):
+        """Generate the shortest valid t-string representation"""
+        if len(self.node.values) == 0:
+            return 't' + min(self.allowed_quotes, key=len) * 2
+
+        candidates = list(self.candidates())
+
+        # Validate all candidates
+        for candidate in candidates:
+            try:
+                minified_t_string = ast.parse(candidate, 'python_minifier.t_string output', mode='eval').body
+            except SyntaxError as syntax_error:
+                raise UnstableMinification(syntax_error, '', candidate)
+
+            try:
+                compare_ast(self.node, minified_t_string)
+            except CompareError as compare_error:
+                raise UnstableMinification(compare_error, '', candidate)
+
+        if not candidates:
+            raise ValueError('Unable to create representation for t-string')
+
+        return min(candidates, key=len)
+
+
+class InterpolationValue(ExpressionPrinter):
+    """
+    A Template String Interpolation Part
+
+    Handles ast.Interpolation nodes (equivalent to FormattedValue for f-strings)
+    """
+
+    def __init__(self, node):
+        super(InterpolationValue, self).__init__()
+
+        assert isinstance(node, ast.Interpolation)
+        self.node = node
+        # Always use all quotes - no restrictions due to PEP 701
+        self.allowed_quotes = ['"', "'", '"""', "'''"]
+        self.candidates = ['']
+
+    def get_candidates(self):
+        """Generate all possible representations of this interpolation"""
+
+        self.printer.delimiter('{')
+
+        if self.is_curly(self.node.value):
+            self.printer.delimiter(' ')
+
+        self._expression(self.node.value)
+
+        # Handle conversion specifiers
+        if self.node.conversion == 115:  # 's'
+            self.printer.append('!s', TokenTypes.Delimiter)
+        elif self.node.conversion == 114:  # 'r'
+            self.printer.append('!r', TokenTypes.Delimiter)
+        elif self.node.conversion == 97:  # 'a'
+            self.printer.append('!a', TokenTypes.Delimiter)
+
+        # Handle format specifications
+        if self.node.format_spec is not None:
+            self.printer.delimiter(':')
+
+            # Format spec is a JoinedStr (f-string) in the AST
+            if isinstance(self.node.format_spec, ast.JoinedStr):
+                import python_minifier.f_string
+                # Use f-string processing for format specs
+                format_candidates = python_minifier.f_string.OuterFString(
+                    self.node.format_spec, pep701=True
+                ).candidates()
+                # Remove the f prefix and quotes to get just the format part
+                format_parts = []
+                for fmt in format_candidates:
+                    if fmt.startswith('f'):
+                        # Remove f prefix and outer quotes
+                        inner = fmt[1:]
+                        if (inner.startswith('"') and inner.endswith('"')) or \
+                           (inner.startswith("'") and inner.endswith("'")):
+                            format_parts.append(inner[1:-1])
+                        elif (inner.startswith('"""') and inner.endswith('"""')) or \
+                             (inner.startswith("'''") and inner.endswith("'''")):
+                            format_parts.append(inner[3:-3])
+                        else:
+                            format_parts.append(inner)
+
+                if format_parts:
+                    self._append(format_parts)
+            else:
+                # Simple constant format spec
+                self.printer.append(str(self.node.format_spec), TokenTypes.Delimiter)
+
+        self.printer.delimiter('}')
+
+        self._finalize()
+        return self.candidates
+
+    def is_curly(self, node):
+        """Check if expression starts with curly braces (needs space)"""
+        if isinstance(node, (ast.SetComp, ast.DictComp, ast.Set, ast.Dict)):
+            return True
+
+        if isinstance(node, (ast.Expr, ast.Attribute, ast.Subscript)):
+            return self.is_curly(node.value)
+
+        if isinstance(node, (ast.Compare, ast.BinOp)):
+            return self.is_curly(node.left)
+
+        if isinstance(node, ast.Call):
+            return self.is_curly(node.func)
+
+        if isinstance(node, ast.BoolOp):
+            return self.is_curly(node.values[0])
+
+        if isinstance(node, ast.IfExp):
+            return self.is_curly(node.body)
+
+        return False
+
+    def visit_Constant(self, node):
+        """Handle constant values in interpolations"""
+        if isinstance(node.value, str):
+            # Use Str class from f_string module for string handling
+            from python_minifier.f_string import Str
+            self.printer.append(str(Str(node.value, self.allowed_quotes, pep701=True)), TokenTypes.NonNumberLiteral)
+        elif isinstance(node.value, bytes):
+            # Use Bytes class from f_string module for bytes handling
+            from python_minifier.f_string import Bytes
+            self.printer.append(str(Bytes(node.value, self.allowed_quotes)), TokenTypes.NonNumberLiteral)
+        else:
+            # Other constants (numbers, None, etc.)
+            super().visit_Constant(node)
+
+    def visit_TemplateStr(self, node):
+        """Handle nested t-strings"""
+        assert isinstance(node, ast.TemplateStr)
+        if self.printer.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword]:
+            self.printer.delimiter(' ')
+        # Nested t-string - no quote restrictions due to PEP 701
+        self._append(TString(node).candidates())
+
+    def visit_JoinedStr(self, node):
+        """Handle nested f-strings in t-strings"""
+        assert isinstance(node, ast.JoinedStr)
+        if self.printer.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword]:
+            self.printer.delimiter(' ')
+
+        import python_minifier.f_string
+        # F-strings nested in t-strings also benefit from PEP 701
+        self._append(python_minifier.f_string.OuterFString(node, pep701=True).candidates())
+
+    def visit_Lambda(self, node):
+        """Handle lambda expressions in interpolations"""
+        self.printer.delimiter('(')
+        super().visit_Lambda(node)
+        self.printer.delimiter(')')
+
+    def _finalize(self):
+        """Finalize the current printer state"""
+        self.candidates = [x + str(self.printer) for x in self.candidates]
+        self.printer._code = ''
+
+    def _append(self, candidates):
+        """Append multiple candidate strings"""
+        self._finalize()
+        self.candidates = [x + y for x in self.candidates for y in candidates]
diff --git a/src/python_minifier/token_printer.py b/src/python_minifier/token_printer.py
@@ -181,6 +181,16 @@ def fstring(self, s):
         self._code += s
         self.previous_token = TokenTypes.NonNumberLiteral
 
+    def tstring(self, s):
+        """Add a template string (t-string) to the output code."""
+        assert isinstance(s, str)
+
+        if self.previous_token in [TokenTypes.Identifier, TokenTypes.Keyword, TokenTypes.SoftKeyword]:
+            self.delimiter(' ')
+
+        self._code += s
+        self.previous_token = TokenTypes.NonNumberLiteral
+
     def delimiter(self, d):
         """Add a delimiter to the output code."""
         assert d in [
diff --git a/test/test_template_strings.py b/test/test_template_strings.py
