Merge branch 'multi_inputs' of https://github.com/s-ball/cpython into multi_inputs

Author: s-ball

Doc/library/xmlrpc.client.rst

@@ -61,6 +61,8 @@ between conformable Python objects and XML on the wire.
    The *headers* parameter is an optional sequence of HTTP headers to send with
    each request, expressed as a sequence of 2-tuples representing the header
    name and value. (e.g. ``[('Header-Name', 'value')]``).
+   If an HTTPS URL is provided, *context* may be :class:`ssl.SSLContext`
+   and configures the SSL settings of the underlying HTTPS connection.
    The obsolete *use_datetime* flag is similar to *use_builtin_types* but it
    applies only to date/time values.
 
@@ -75,9 +77,7 @@ between conformable Python objects and XML on the wire.
    portion will be base64-encoded as an HTTP 'Authorization' header, and sent to
    the remote server as part of the connection process when invoking an XML-RPC
    method.  You only need to use this if the remote server requires a Basic
-   Authentication user and password. If an HTTPS URL is provided, *context* may
-   be :class:`ssl.SSLContext` and configures the SSL settings of the underlying
-   HTTPS connection.
+   Authentication user and password.
 
    The returned instance is a proxy object with methods that can be used to invoke
    corresponding RPC calls on the remote server.  If the remote server supports the

Lib/test/test_bytes.py

@@ -2380,12 +2380,22 @@ def ass_subscript(b, a):  # MODIFIES!
             b.wait()
             a[:] = c
 
+        def ass_subscript2(b, a, c):  # MODIFIES!
+            b.wait()
+            a[:] = c
+            assert b'\xdd' not in a
+
         def mod(b, a):
             c = tuple(range(4096))
             b.wait()
             try: a % c
             except TypeError: pass
 
+        def mod2(b, a, c):
+            b.wait()
+            d = a % c
+            assert b'\xdd' not in d
+
         def repr_(b, a):
             b.wait()
             repr(a)
@@ -2503,7 +2513,9 @@ def check(funcs, a=None, *args):
 
         check([clear] + [contains] * 10)
         check([clear] + [subscript] * 10)
+        check([clear2] + [ass_subscript2] * 10, None, bytearray(b'0' * 0x400000))
         check([clear] + [mod] * 10, bytearray(b'%d' * 4096))
+        check([clear2] + [mod2] * 10, bytearray(b'%s'), bytearray(b'0' * 0x400000))
 
         check([clear] + [capitalize] * 10, bytearray(b'a' * 0x40000))
         check([clear] + [center] * 10, bytearray(b'a' * 0x40000))

Lib/test/test_grammar.py

@@ -1972,6 +1972,18 @@ async def foo():
         with self.assertRaises(Done):
             foo().send(None)
 
+    def test_complex_lambda(self):
+        def test1(foo, bar):
+            return ""
+
+        def test2():
+            return f"{test1(
+                foo=lambda: '、、、、、、、、、、、、、、、、、',
+                bar=lambda: 'abcdefghijklmnopqrstuvwxyz 123456789 123456789',
+            )}"
+
+        self.assertEqual(test2(), "")
+
 
 if __name__ == '__main__':
     unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2025-02-17-15-32-26.gh-issue-129107.fPPBLw.rst

@@ -0,0 +1 @@
+Fix two more :class:`bytearray` functions for :term:`free threading`.

Misc/NEWS.d/next/Core_and_Builtins/2025-02-27-15-07-06.gh-issue-130618.JTcsRB.rst

@@ -0,0 +1,3 @@
+Fix a bug that was causing ``UnicodeDecodeError`` or ``SystemError`` to be
+raised when using f-strings with ``lambda`` expressions with non-ASCII
+characters. Patch by Pablo Galindo

Objects/bytearrayobject.c

@@ -864,9 +864,16 @@ static int
 bytearray_ass_subscript(PyObject *op, PyObject *index, PyObject *values)
 {
     int ret;
-    Py_BEGIN_CRITICAL_SECTION(op);
-    ret = bytearray_ass_subscript_lock_held(op, index, values);
-    Py_END_CRITICAL_SECTION();
+    if (values != NULL && PyByteArray_Check(values)) {
+        Py_BEGIN_CRITICAL_SECTION2(op, values);
+        ret = bytearray_ass_subscript_lock_held(op, index, values);
+        Py_END_CRITICAL_SECTION2();
+    }
+    else {
+        Py_BEGIN_CRITICAL_SECTION(op);
+        ret = bytearray_ass_subscript_lock_held(op, index, values);
+        Py_END_CRITICAL_SECTION();
+    }
     return ret;
 }
 
@@ -2751,9 +2758,16 @@ static PyObject *
 bytearray_mod(PyObject *v, PyObject *w)
 {
     PyObject *ret;
-    Py_BEGIN_CRITICAL_SECTION(v);
-    ret = bytearray_mod_lock_held(v, w);
-    Py_END_CRITICAL_SECTION();
+    if (PyByteArray_Check(w)) {
+        Py_BEGIN_CRITICAL_SECTION2(v, w);
+        ret = bytearray_mod_lock_held(v, w);
+        Py_END_CRITICAL_SECTION2();
+    }
+    else {
+        Py_BEGIN_CRITICAL_SECTION(v);
+        ret = bytearray_mod_lock_held(v, w);
+        Py_END_CRITICAL_SECTION();
+    }
     return ret;
 }
 

Parser/lexer/lexer.c

@@ -211,9 +211,13 @@ _PyLexer_update_fstring_expr(struct tok_state *tok, char cur)
             break;
         case '}':
         case '!':
-        case ':':
             tok_mode->last_expr_end = strlen(tok->start);
             break;
+        case ':':
+            if (tok_mode->last_expr_end == -1) {
+               tok_mode->last_expr_end = strlen(tok->start);
+            }
+            break;
         default:
             Py_UNREACHABLE();
     }