Merge branch 'main' into gh-159091-pyfunction-getannotations

Author: hetaozdh

.github/ISSUE_TEMPLATE/bug.yml

@@ -34,7 +34,6 @@ body:
       label: "CPython versions tested on:"
       multiple: true
       options:
-        - "3.10"
         - "3.11"
         - "3.12"
         - "3.13"

.github/ISSUE_TEMPLATE/crash.yml

@@ -28,7 +28,6 @@ body:
       label: "CPython versions tested on:"
       multiple: true
       options:
-        - "3.10"
         - "3.11"
         - "3.12"
         - "3.13"

.github/dependabot.yml

@@ -92,18 +92,6 @@ updates:
     cooldown:
       default-days: 14
 
-  - package-ecosystem: "github-actions"
-    target-branch: "3.10"
-    directory: "/"
-    schedule:
-      interval: "quarterly"
-    labels: ["skip issue", "skip news"]
-    groups:
-      actions:
-        patterns: ["*"]
-    cooldown:
-      default-days: 14
-
   # Only bump bugfix branches for pip. Remove
   # the entry when branch goes security-only.
   - package-ecosystem: "pip"
@@ -129,15 +117,3 @@ updates:
         patterns: ["*"]
     cooldown:
       default-days: 14
-
-  - package-ecosystem: "pip"
-    target-branch: "3.13"
-    directory: "/Tools/"
-    schedule:
-      interval: "quarterly"
-    labels: ["skip issue", "skip news"]
-    groups:
-      pip:
-        patterns: ["*"]
-    cooldown:
-      default-days: 14

.github/workflows/mypy.yml

@@ -69,7 +69,7 @@ jobs:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+      - uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
         with:
           python-version: "3.15"
           activate-environment: true

.github/workflows/reusable-cifuzz.yml

@@ -43,7 +43,7 @@ jobs:
           path: ./out/artifacts
       - name: Upload SARIF
         if: always() && steps.build.outcome == 'success'
-        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
         with:
           sarif_file: cifuzz-sarif/results.sarif
           checkout_path: cifuzz-sarif

Doc/c-api/bytes.rst

@@ -464,3 +464,112 @@ Low-level API
            return NULL;
        }
        return (char*)PyBytesWriter_GetData(writer) + pos;
+
+
+Example creating the string ``b'abc'``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Example creating the bytes string ``b"abc"``, with a fixed size of 3 bytes::
+
+    PyObject* create_abc(void)
+    {
+        PyBytesWriter *writer = PyBytesWriter_Create(3);
+        if (writer == NULL) {
+            return NULL;
+        }
+
+        char *str = PyBytesWriter_GetData(writer);
+        memcpy(str, "abc", 3);
+        return PyBytesWriter_Finish(writer);
+    }
+
+Variant using a pointer to compute the final size::
+
+    PyObject* create_abc_ptr(void)
+    {
+        PyBytesWriter *writer = PyBytesWriter_Create(3);
+        if (writer == NULL) {
+            return NULL;
+        }
+
+        char *str = PyBytesWriter_GetData(writer);
+        memcpy(str, "abc", 3);
+        str += 1;
+        return PyBytesWriter_FinishWithPointer(writer, str);
+    }
+
+
+Update ``PyBytes_FromStringAndSize()`` code
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Example of code using the soft deprecated
+``PyBytes_FromStringAndSize(NULL, size)`` API::
+
+    int copy_bytes(char *dest, const char *src, Py_ssize_t num_bytes)
+    {
+        ...
+    }
+
+    PyObject* create_string(const char *start, Py_ssize_t num_bytes)
+    {
+        PyObject *result = PyBytes_FromStringAndSize(NULL, num_bytes);
+        if (result == NULL) {
+            return NULL;
+        }
+        if (copy_bytes(PyBytes_AS_STRING(result), start, num_bytes) < 0) {
+            Py_CLEAR(result);
+        }
+        return result;
+    }
+
+It can now be updated to::
+
+    PyObject* create_string(const char *start, Py_ssize_t num_bytes)
+    {
+        PyBytesWriter *writer = PyBytesWriter_Create(num_bytes);
+        if (writer == NULL) {
+            return NULL;
+        }
+        if (copy_bytes(PyBytesWriter_GetData(writer), start, num_bytes) < 0) {
+            PyBytesWriter_Discard(writer);
+            return NULL;
+        }
+        return PyBytesWriter_Finish(writer);
+    }
+
+
+Update ``_PyBytes_Resize()`` code
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Example of code using the soft deprecated ``_PyBytes_Resize()`` API::
+
+    void create_string(Py_ssize_t size)
+    {
+        PyObject *bytes = PyBytes_FromStringAndSize(NULL, size);
+        if (bytes == NULL) {
+            return NULL;
+        }
+        char *str = PyBytes_AS_STRING(bytes);
+
+        // ... write data into str ...
+
+        if (_PyBytes_Resize(&bytes, (str - PyBytes_AS_STRING(bytes)))) {
+            return NULL;
+        }
+        return bytes;
+    }
+
+It can now be updated to::
+
+    void create_string(Py_ssize_t size)
+    {
+        PyBytesWriter *writer = PyBytesWriter_Create(size);
+        if (writer == NULL) {
+            return NULL;
+        }
+        char *str = PyBytesWriter_GetData(writer);
+
+        // ... write data into str ...
+
+        return PyBytesWriter_FinishWithPointer(writer, str);
+    }

Doc/c-api/marshal.rst

@@ -43,14 +43,40 @@ and :exc:`MemoryError` if memory allocation fails.
    This function can fail, in which case it sets the error indicator.
    Use :c:func:`PyErr_Occurred` to check for that.
 
+   .. note::
+
+      In Python 3.15 and earlier, this function does not set the error
+      indicator if writing to *file* fails.
+      The same caveat applies as for :c:func:`PyMarshal_WriteObjectToFile`.
+
 .. c:function:: void PyMarshal_WriteObjectToFile(PyObject *value, FILE *file, int version)
 
    Marshal a Python object, *value*, to *file*.
    *version* indicates the file format.
 
+   The marshalled representation of *value* is built in memory
+   and then written to *file*.
+   Nothing is written if *value* cannot be marshalled.
+
    This function can fail, in which case it sets the error indicator.
    Use :c:func:`PyErr_Occurred` to check for that.
 
+   .. note::
+
+      In Python 3.15 and earlier, this function can write only part of the
+      data to *file* and return without setting the error indicator, for
+      example if *value* contains an object which cannot be marshalled or
+      if writing to *file* fails (see :gh:`155907`).
+      Code which has to support these versions cannot rely on
+      :c:func:`PyErr_Occurred` alone to know that all the data was written.
+      It can use :c:func:`PyMarshal_WriteObjectToString` and write the
+      result itself, or validate what was written.
+
+   .. versionchanged:: next
+      Previously, the data was written to *file* as it was produced,
+      using a buffer of constant size,
+      and incomplete data was written if *value* could not be marshalled.
+
 .. c:function:: PyObject* PyMarshal_WriteObjectToString(PyObject *value, int version)
 
    Return a bytes object containing the marshalled representation of *value*.

Doc/library/concurrent.interpreters.rst

@@ -224,11 +224,15 @@ This module defines the following functions:
    Initialize a new (idle) Python interpreter
    and return a :class:`Interpreter` object for it.
 
-.. function:: create_queue()
+.. function:: create_queue(maxsize=0)
 
    Initialize a new cross-interpreter queue and return a :class:`Queue`
    object for it.
 
+   *maxsize* is an integer that sets the upperbound limit on the number of
+   items that can be placed in the queue. Insertion will be blocked once this
+   size has been reached, until queue items are consumed. If *maxsize* is
+   less than or equal to zero, the queue size is infinite.
 
 Interpreter objects
 ^^^^^^^^^^^^^^^^^^^
@@ -268,7 +272,7 @@ Interpreter objects
       Some objects are actually shared and some are copied efficiently,
       but most are copied via :mod:`pickle`.  See :ref:`interp-object-sharing`.
 
-   .. method:: exec(code, /, dedent=True)
+   .. method:: exec(code, /)
 
       Run the given source code in the interpreter (in the current thread).
 
@@ -319,7 +323,9 @@ Communicating Between Interpreters
 .. class:: Queue(id)
 
    A wrapper around a low-level, cross-interpreter queue, which
-   implements the :class:`queue.Queue` interface.  The underlying queue
+   implements all the methods of :class:`queue.Queue` except for
+   :meth:`~queue.Queue.task_done`, :meth:`~queue.Queue.join`
+   and :meth:`~queue.Queue.shutdown`.  The underlying queue
    can only be created through :func:`create_queue`.
 
    Some objects are actually shared and some are copied efficiently,
@@ -331,17 +337,59 @@ Communicating Between Interpreters
 
       The queue's ID.
 
+   .. method:: qsize()
 
-.. exception:: QueueEmptyError
+      Return the number of items in the queue.
+
+   .. method:: empty()
+
+      Return ``True`` if the queue is empty, ``False`` otherwise.
+
+   .. method:: full()
+
+      Return ``True`` if the queue is full, ``False`` otherwise.
+
+   .. method:: put(obj, block=True, timeout=None)
+
+      Put *obj* into the queue.  If optional args *block* is true and
+      *timeout* is ``None`` (the default), block if necessary until a free
+      slot is available.  If *timeout* is a positive number, it blocks at
+      most *timeout* seconds and raises the :exc:`QueueFull` exception if
+      no free slot was available within that time.  Otherwise (*block* is
+      false), put an object on the queue if a free slot is immediately
+      available, else raise the :exc:`QueueFull` exception (*timeout* is
+      ignored in that case).
+
+   .. method:: put_nowait(obj)
+
+      Equivalent to ``put(obj, block=False)``.
+
+   .. method:: get(block=True, timeout=None)
+
+      Remove and return an object from the queue.  If optional args *block*
+      is true and *timeout* is ``None`` (the default), block if necessary
+      until an object is available.  If *timeout* is a positive number, it
+      blocks at most *timeout* seconds and raises the :exc:`QueueEmpty`
+      exception if no object was available within that time.  Otherwise
+      (*block* is false), return an object if one is immediately available,
+      else raise the :exc:`QueueEmpty` exception (*timeout* is ignored in
+      that case).
+
+   .. method:: get_nowait()
+
+      Equivalent to ``get(block=False)``.
+
+
+.. exception:: QueueEmpty
 
    This exception, a subclass of :exc:`queue.Empty`, is raised from
-   :meth:`!Queue.get` and :meth:`!Queue.get_nowait` when the queue
+   :meth:`Queue.get` and :meth:`Queue.get_nowait` when the queue
    is empty.
 
-.. exception:: QueueFullError
+.. exception:: QueueFull
 
    This exception, a subclass of :exc:`queue.Full`, is raised from
-   :meth:`!Queue.put` and :meth:`!Queue.put_nowait` when the queue
+   :meth:`Queue.put` and :meth:`Queue.put_nowait` when the queue
    is full.
 
 
@@ -382,3 +430,17 @@ Creating an interpreter and running code in it::
 
     t = interp.call_in_thread(run)
     t.join()
+
+Communicating between interpreters with a queue::
+
+    from concurrent import interpreters
+
+    interp = interpreters.create()
+    queue = interpreters.create_queue()
+
+    def worker(queue):
+        queue.put('spam!')
+
+    t = interp.call_in_thread(worker, queue)
+    print(queue.get())
+    t.join()

Doc/library/ctypes.rst

@@ -1579,7 +1579,10 @@ way is to instantiate :py:class:`CDLL` or one of its subclasses:
    :mod:`!ctypes` maintains a thread-local copy of the system's :data:`errno`
    variable; if you call foreign functions created with ``use_errno=True`` then the
    :data:`errno` value before the function call is swapped with the ctypes private
-   copy, the same happens immediately after the function call.
+   copy, the same happens immediately after the function call. This mechanism only
+   works for libraries that use the same C runtime library as the interpreter itself.
+   A library linked against a different C runtime (for example, a different CRT on
+   Windows) has its own :data:`errno`, which :mod:`!ctypes` cannot observe.
 
    The function :func:`ctypes.get_errno` returns the value of the ctypes private
    copy, and the function :func:`ctypes.set_errno` changes the ctypes private copy

Doc/library/idle.rst

@@ -931,6 +931,8 @@ the mainloop call.  One then gets a shell prompt immediately and can
 interact with the live application.  One just has to remember to
 re-enable the mainloop call when running in standard Python.
 
+.. _idle-no-subprocess:
+
 Running without a subprocess
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^