Merge remote-tracking branch 'upstream/main' into remove-pragma

Doc/c-api/typeobj.rst

@@ -1592,7 +1592,7 @@ and :c:data:`PyType_Type` effectively act as defaults.)
    weak references to the type object itself.
 
    It is an error to set both the :c:macro:`Py_TPFLAGS_MANAGED_WEAKREF` bit and
-   :c:member:`~PyTypeObject.tp_weaklist`.
+   :c:member:`~PyTypeObject.tp_weaklistoffset`.
 
    **Inheritance:**
 
@@ -1604,7 +1604,7 @@ and :c:data:`PyType_Type` effectively act as defaults.)
    **Default:**
 
    If the :c:macro:`Py_TPFLAGS_MANAGED_WEAKREF` bit is set in the
-   :c:member:`~PyTypeObject.tp_dict` field, then
+   :c:member:`~PyTypeObject.tp_flags` field, then
    :c:member:`~PyTypeObject.tp_weaklistoffset` will be set to a negative value,
    to indicate that it is unsafe to use this field.
 

Doc/howto/logging.rst

@@ -403,11 +403,13 @@ following diagram.
      function updateBody(theme) {
         let elem = document.body;
 
+        elem.classList.remove('dark-theme');
+        elem.classList.remove('light-theme');
         if (theme === 'dark') {
             elem.classList.add('dark-theme');
         }
-        else {
-            elem.classList.remove('dark-theme');
+        else if (theme === 'light') {
+            elem.classList.add('light-theme');
         }
      }
 

Doc/library/ctypes.rst

@@ -272,8 +272,12 @@ complex types are available:
 +----------------------------------+---------------------------------+-----------------+
 | ctypes type                      | C type                          | Python type     |
 +==================================+=================================+=================+
+| :class:`c_float_complex`         | :c:expr:`float complex`         | complex         |
++----------------------------------+---------------------------------+-----------------+
 | :class:`c_double_complex`        | :c:expr:`double complex`        | complex         |
 +----------------------------------+---------------------------------+-----------------+
+| :class:`c_longdouble_complex`    | :c:expr:`long double complex`   | complex         |
++----------------------------------+---------------------------------+-----------------+
 
 
 All these types can be created by calling them with an optional initializer of
@@ -2302,6 +2306,22 @@ These are the fundamental ctypes data types:
    .. versionadded:: 3.14
 
 
+.. class:: c_float_complex
+
+   Represents the C :c:expr:`float complex` datatype, if available.  The
+   constructor accepts an optional :class:`complex` initializer.
+
+   .. versionadded:: 3.14
+
+
+.. class:: c_longdouble_complex
+
+   Represents the C :c:expr:`long double complex` datatype, if available.  The
+   constructor accepts an optional :class:`complex` initializer.
+
+   .. versionadded:: 3.14
+
+
 .. class:: c_int
 
    Represents the C :c:expr:`signed int` datatype.  The constructor accepts an

Doc/library/os.rst

@@ -1724,10 +1724,27 @@ or `the MSDN <https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx>`_ on Windo
       Added support for pipes on Windows.
 
 
-.. function:: splice(src, dst, count, offset_src=None, offset_dst=None)
+.. function:: splice(src, dst, count, offset_src=None, offset_dst=None, flags=0)
 
    Transfer *count* bytes from file descriptor *src*, starting from offset
    *offset_src*, to file descriptor *dst*, starting from offset *offset_dst*.
+
+   The splicing behaviour can be modified by specifying a *flags* value.
+   Any of the following variables may used, combined using bitwise OR
+   (the ``|`` operator):
+
+   * If :const:`SPLICE_F_MOVE` is specified,
+     the kernel is asked to move pages instead of copying,
+     but pages may still be copied if the kernel cannot move the pages from the pipe.
+
+   * If :const:`SPLICE_F_NONBLOCK` is specified,
+     the kernel is asked to not block on I/O.
+     This makes the splice pipe operations nonblocking,
+     but splice may nevertheless block because the spliced file descriptors may block.
+
+   * If :const:`SPLICE_F_MORE` is specified,
+     it hints to the kernel that more data will be coming in a subsequent splice.
+
    At least one of the file descriptors must refer to a pipe. If *offset_src*
    is ``None``, then *src* is read from the current position; respectively for
    *offset_dst*. The offset associated to the file descriptor that refers to a
@@ -1746,6 +1763,8 @@ or `the MSDN <https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx>`_ on Windo
    make sense to block because there are no writers connected to the write end
    of the pipe.
 
+   .. seealso:: The :manpage:`splice(2)` man page.
+
    .. availability:: Linux >= 2.6.17 with glibc >= 2.5
 
    .. versionadded:: 3.10

Doc/library/pathlib.rst

@@ -1554,11 +1554,6 @@ Copying, renaming and deleting
       permissions. After the copy is complete, users may wish to call
       :meth:`Path.chmod` to set the permissions of the target file.
 
-   .. warning::
-      On old builds of Windows (before Windows 10 build 19041), this method
-      raises :exc:`OSError` when a symlink to a directory is encountered and
-      *follow_symlinks* is false.
-
    .. versionadded:: 3.14
 
 

Doc/library/socketserver.rst

@@ -126,6 +126,12 @@ server is the address family.
       waits until all non-daemon threads complete, except if
       :attr:`block_on_close` attribute is ``False``.
 
+   .. attribute:: max_children
+
+      Specify how many child processes will exist to handle requests at a time
+      for :class:`ForkingMixIn`.  If the limit is reached,
+      new requests will wait until one child process has finished.
+
    .. attribute:: daemon_threads
 
       For :class:`ThreadingMixIn` use daemonic threads by setting

Doc/whatsnew/3.14.rst

@@ -305,6 +305,12 @@ Porting to Python 3.14
 This section lists previously described changes and other bugfixes
 that may require changes to your code.
 
+Changes in the Python API
+-------------------------
+
+* :class:`functools.partial` is now a method descriptor.
+  Wrap it in :func:`staticmethod` if you want to preserve the old behavior.
+  (Contributed by Serhiy Storchaka and Dominykas Grigonis in :gh:`121027`.)
 
 Build Changes
 =============

Include/cpython/modsupport.h

@@ -0,0 +1,26 @@
+#ifndef Py_CPYTHON_MODSUPPORT_H
+#  error "this header file must not be included directly"
+#endif
+
+// A data structure that can be used to run initialization code once in a
+// thread-safe manner. The C++11 equivalent is std::call_once.
+typedef struct {
+    uint8_t v;
+} _PyOnceFlag;
+
+typedef struct _PyArg_Parser {
+    const char *format;
+    const char * const *keywords;
+    const char *fname;
+    const char *custom_msg;
+    _PyOnceFlag once;       /* atomic one-time initialization flag */
+    int is_kwtuple_owned;   /* does this parser own the kwtuple object? */
+    int pos;                /* number of positional-only arguments */
+    int min;                /* minimal number of arguments */
+    int max;                /* maximal number of positional arguments */
+    PyObject *kwtuple;      /* tuple of keyword parameter names */
+    struct _PyArg_Parser *next;
+} _PyArg_Parser;
+
+PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *,
+                                                 struct _PyArg_Parser *, ...);

Include/internal/pycore_lock.h

@@ -128,12 +128,6 @@ _PyRawMutex_Unlock(_PyRawMutex *m)
     _PyRawMutex_UnlockSlow(m);
 }
 
-// A data structure that can be used to run initialization code once in a
-// thread-safe manner. The C++11 equivalent is std::call_once.
-typedef struct {
-    uint8_t v;
-} _PyOnceFlag;
-
 // Type signature for one-time initialization functions. The function should
 // return 0 on success and -1 on failure.
 typedef int _Py_once_fn_t(void *arg);

Include/internal/pycore_modsupport.h

@@ -67,24 +67,6 @@ PyAPI_FUNC(void) _PyArg_BadArgument(
 
 // --- _PyArg_Parser API ---------------------------------------------------
 
-typedef struct _PyArg_Parser {
-    const char *format;
-    const char * const *keywords;
-    const char *fname;
-    const char *custom_msg;
-    _PyOnceFlag once;       /* atomic one-time initialization flag */
-    int is_kwtuple_owned;   /* does this parser own the kwtuple object? */
-    int pos;                /* number of positional-only arguments */
-    int min;                /* minimal number of arguments */
-    int max;                /* maximal number of positional arguments */
-    PyObject *kwtuple;      /* tuple of keyword parameter names */
-    struct _PyArg_Parser *next;
-} _PyArg_Parser;
-
-// Export for '_testclinic' shared extension
-PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *,
-                                                 struct _PyArg_Parser *, ...);
-
 // Export for '_dbm' shared extension
 PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords(
     PyObject *const *args,

Include/internal/pycore_runtime.h

@@ -55,12 +55,15 @@ typedef struct _Py_DebugOffsets {
     uint64_t version;
     // Runtime state offset;
     struct _runtime_state {
+        uint64_t size;
         uint64_t finalizing;
         uint64_t interpreters_head;
     } runtime_state;
 
     // Interpreter state offset;
     struct _interpreter_state {
+        uint64_t size;
+        uint64_t id;
         uint64_t next;
         uint64_t threads_head;
         uint64_t gc;
@@ -74,16 +77,20 @@ typedef struct _Py_DebugOffsets {
 
     // Thread state offset;
     struct _thread_state{
+        uint64_t size;
         uint64_t prev;
         uint64_t next;
         uint64_t interp;
         uint64_t current_frame;
         uint64_t thread_id;
         uint64_t native_thread_id;
+        uint64_t datastack_chunk;
+        uint64_t status;
     } thread_state;
 
     // InterpreterFrame offset;
     struct _interpreter_frame {
+        uint64_t size;
         uint64_t previous;
         uint64_t executable;
         uint64_t instr_ptr;
@@ -93,14 +100,17 @@ typedef struct _Py_DebugOffsets {
 
     // CFrame offset;
     struct _cframe {
+        uint64_t size;
         uint64_t current_frame;
         uint64_t previous;
     } cframe;
 
     // Code object offset;
     struct _code_object {
+        uint64_t size;
         uint64_t filename;
         uint64_t name;
+        uint64_t qualname;
         uint64_t linetable;
         uint64_t firstlineno;
         uint64_t argcount;
@@ -111,25 +121,35 @@ typedef struct _Py_DebugOffsets {
 
     // PyObject offset;
     struct _pyobject {
+        uint64_t size;
         uint64_t ob_type;
     } pyobject;
 
     // PyTypeObject object offset;
     struct _type_object {
+        uint64_t size;
         uint64_t tp_name;
     } type_object;
 
     // PyTuple object offset;
     struct _tuple_object {
+        uint64_t size;
         uint64_t ob_item;
     } tuple_object;
 
     // Unicode object offset;
     struct _unicode_object {
+        uint64_t size;
         uint64_t state;
         uint64_t length;
         size_t asciiobject_size;
     } unicode_object;
+
+    // GC runtime state offset;
+    struct _gc {
+        uint64_t size;
+        uint64_t collecting;
+    } gc;
 } _Py_DebugOffsets;
 
 /* Reference tracer state */

Include/internal/pycore_runtime_init.h

@@ -35,10 +35,13 @@ extern PyTypeObject _PyExc_MemoryError;
             .cookie = "xdebugpy", \
             .version = PY_VERSION_HEX, \
             .runtime_state = { \
+                .size = sizeof(_PyRuntimeState), \
                 .finalizing = offsetof(_PyRuntimeState, _finalizing), \
                 .interpreters_head = offsetof(_PyRuntimeState, interpreters.head), \
             }, \
             .interpreter_state = { \
+                .size = sizeof(PyInterpreterState), \
+                .id = offsetof(PyInterpreterState, id), \
                 .next = offsetof(PyInterpreterState, next), \
                 .threads_head = offsetof(PyInterpreterState, threads.head), \
                 .gc = offsetof(PyInterpreterState, gc), \
@@ -50,23 +53,29 @@ extern PyTypeObject _PyExc_MemoryError;
                 .gil_runtime_state_holder = offsetof(PyInterpreterState, _gil.last_holder), \
             }, \
             .thread_state = { \
+                .size = sizeof(PyThreadState), \
                 .prev = offsetof(PyThreadState, prev), \
                 .next = offsetof(PyThreadState, next), \
                 .interp = offsetof(PyThreadState, interp), \
                 .current_frame = offsetof(PyThreadState, current_frame), \
                 .thread_id = offsetof(PyThreadState, thread_id), \
                 .native_thread_id = offsetof(PyThreadState, native_thread_id), \
+                .datastack_chunk = offsetof(PyThreadState, datastack_chunk), \
+                .status = offsetof(PyThreadState, _status), \
             }, \
             .interpreter_frame = { \
+                .size = sizeof(_PyInterpreterFrame), \
                 .previous = offsetof(_PyInterpreterFrame, previous), \
                 .executable = offsetof(_PyInterpreterFrame, f_executable), \
                 .instr_ptr = offsetof(_PyInterpreterFrame, instr_ptr), \
                 .localsplus = offsetof(_PyInterpreterFrame, localsplus), \
                 .owner = offsetof(_PyInterpreterFrame, owner), \
             }, \
             .code_object = { \
+                .size = sizeof(PyCodeObject), \
                 .filename = offsetof(PyCodeObject, co_filename), \
                 .name = offsetof(PyCodeObject, co_name), \
+                .qualname = offsetof(PyCodeObject, co_qualname), \
                 .linetable = offsetof(PyCodeObject, co_linetable), \
                 .firstlineno = offsetof(PyCodeObject, co_firstlineno), \
                 .argcount = offsetof(PyCodeObject, co_argcount), \
@@ -75,19 +84,27 @@ extern PyTypeObject _PyExc_MemoryError;
                 .co_code_adaptive = offsetof(PyCodeObject, co_code_adaptive), \
             }, \
             .pyobject = { \
+                .size = sizeof(PyObject), \
                 .ob_type = offsetof(PyObject, ob_type), \
             }, \
             .type_object = { \
+                .size = sizeof(PyTypeObject), \
                 .tp_name = offsetof(PyTypeObject, tp_name), \
             }, \
             .tuple_object = { \
+                .size = sizeof(PyTupleObject), \
                 .ob_item = offsetof(PyTupleObject, ob_item), \
             }, \
             .unicode_object = { \
+                .size = sizeof(PyUnicodeObject), \
                 .state = offsetof(PyUnicodeObject, _base._base.state), \
                 .length = offsetof(PyUnicodeObject, _base._base.length), \
                 .asciiobject_size = sizeof(PyASCIIObject), \
             }, \
+            .gc = { \
+                .size = sizeof(struct _gc_runtime_state), \
+                .collecting = offsetof(struct _gc_runtime_state, collecting), \
+            }, \
         }, \
         .allocators = { \
             .standard = _pymem_allocators_standard_INIT(runtime), \