[pull] main from python:main

Doc/howto/logging.rst

@@ -302,10 +302,10 @@ reading the following sections. If you're ready for that, grab some of your
 favourite beverage and carry on.
 
 If your logging needs are simple, then use the above examples to incorporate
-logging into your own scripts, and if you run into problems or don't
-understand something, please post a question on the comp.lang.python Usenet
-group (available at https://groups.google.com/g/comp.lang.python) and you
-should receive help before too long.
+logging into your own scripts, and if you run into problems or don't understand
+something, please post a question in the Help category of the `Python
+discussion forum <https://discuss.python.org/c/help/7>`_ and you should receive
+help before too long.
 
 Still here? You can carry on reading the next few sections, which provide a
 slightly more advanced/in-depth tutorial than the basic one above. After that,

Doc/whatsnew/3.14.rst

@@ -2323,8 +2323,7 @@ uuid
   * :func:`~uuid.uuid3` and :func:`~uuid.uuid5` are both roughly 40% faster
     for 16-byte names and 20% faster for 1024-byte names. Performance for
     longer names remains unchanged.
-  * :func:`~uuid.uuid4` and :func:`~uuid.uuid8` are 30% and 40% faster
-    respectively.
+  * :func:`~uuid.uuid4` is 30% faster.
 
   (Contributed by Bénédikt Tran in :gh:`128150`.)
 

Grammar/python.gram

@@ -987,7 +987,10 @@ tstring[expr_ty] (memo):
             _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c)) }
 
 string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) }
-strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string|tstring)+ { _PyPegen_concatenate_strings(p, a, EXTRA) }
+strings[expr_ty] (memo):
+    | invalid_string_tstring_concat
+    | a[asdl_expr_seq*]=(fstring|string)+ { _PyPegen_concatenate_strings(p, a, EXTRA) }
+    | a[asdl_expr_seq*]=tstring+ { _PyPegen_concatenate_tstrings(p, a, EXTRA) }
 
 list[expr_ty]:
     | '[' a=[star_named_expressions] ']' { _PyAST_List(a, Load, EXTRA) }
@@ -1553,6 +1556,12 @@ invalid_tstring_conversion_character:
     | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: missing conversion character") }
     | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: invalid conversion character") }
 
+invalid_string_tstring_concat:
+    | a=(fstring|string)+ b[expr_ty]=tstring {
+        RAISE_SYNTAX_ERROR_KNOWN_RANGE(PyPegen_last_item(a, expr_ty), b, "cannot mix t-string literals with string or bytes literals") }
+    | a=tstring+ b[expr_ty]=(fstring|string) {
+        RAISE_SYNTAX_ERROR_KNOWN_RANGE(PyPegen_last_item(a, expr_ty), b, "cannot mix t-string literals with string or bytes literals") }
+
 invalid_arithmetic:
     | sum ('+'|'-'|'*'|'/'|'%'|'//'|'@') a='not' b=inversion { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "'not' after an operator must be parenthesized") }
 invalid_factor:

Lib/_ast_unparse.py

@@ -626,35 +626,11 @@ def _write_ftstring(self, values, prefix):
             )
         self._ftstring_helper(fstring_parts)
 
-    def _tstring_helper(self, node):
-        if not node.values:
-            self._write_ftstring([], "t")
-            return
-        last_idx = 0
-        for i, value in enumerate(node.values):
-            # This can happen if we have an implicit concat of a t-string
-            # with an f-string
-            if isinstance(value, FormattedValue):
-                if i > last_idx:
-                    # Write t-string until here
-                    self._write_ftstring(node.values[last_idx:i], "t")
-                    self.write(" ")
-                # Write f-string with the current formatted value
-                self._write_ftstring([node.values[i]], "f")
-                if i + 1 < len(node.values):
-                    # Only add a space if there are more values after this
-                    self.write(" ")
-                last_idx = i + 1
-
-        if last_idx < len(node.values):
-            # Write t-string from last_idx to end
-            self._write_ftstring(node.values[last_idx:], "t")
-
     def visit_JoinedStr(self, node):
         self._write_ftstring(node.values, "f")
 
     def visit_TemplateStr(self, node):
-        self._tstring_helper(node)
+        self._write_ftstring(node.values, "t")
 
     def _write_ftstring_inner(self, node, is_format_spec=False):
         if isinstance(node, JoinedStr):