Merge branch 'main' into issue-91602

Author: felixxm

.github/CODEOWNERS

@@ -42,6 +42,9 @@ Lib/test/test_type_*.py       @JelleZijlstra
 Lib/test/test_capi/test_misc.py  @markshannon @gvanrossum
 Tools/c-analyzer/             @ericsnowcurrently
 
+# dbm
+**/*dbm*                      @corona10 @erlend-aasland @serhiy-storchaka
+
 # Exceptions
 Lib/traceback.py              @iritkatriel
 Lib/test/test_except*.py      @iritkatriel

Doc/c-api/structures.rst

@@ -551,11 +551,11 @@ The following flags can be used with :c:member:`PyMemberDef.flags`:
    from ``PyObject``.
 
    Can only be used as part of :c:member:`Py_tp_members <PyTypeObject.tp_members>`
-   :c:type:`slot <PyTypeSlot>` when creating a class using negative
+   :c:type:`slot <PyType_Slot>` when creating a class using negative
    :c:member:`~PyType_Spec.basicsize`.
    It is mandatory in that case.
 
-   This flag is only used in :c:type:`PyTypeSlot`.
+   This flag is only used in :c:type:`PyType_Slot`.
    When setting :c:member:`~PyTypeObject.tp_members` during
    class creation, Python clears it and sets
    :c:member:`PyMemberDef.offset` to the offset from the ``PyObject`` struct.
@@ -693,7 +693,8 @@ Defining Getters and Setters
 
    .. c:member:: setter set
 
-      Optional C function to set or delete the attribute, if omitted the attribute is readonly.
+      Optional C function to set or delete the attribute.
+      If ``NULL``, the attribute is read-only.
 
    .. c:member:: const char* doc
 
@@ -703,18 +704,18 @@ Defining Getters and Setters
 
       Optional function pointer, providing additional data for getter and setter.
 
-   The ``get`` function takes one :c:expr:`PyObject*` parameter (the
-   instance) and a function pointer (the associated ``closure``)::
+.. c:type:: PyObject *(*getter)(PyObject *, void *)
 
-      typedef PyObject *(*getter)(PyObject *, void *);
+   The ``get`` function takes one :c:expr:`PyObject*` parameter (the
+   instance) and a function pointer (the associated ``closure``):
 
    It should return a new reference on success or ``NULL`` with a set exception
    on failure.
 
-   ``set`` functions take two :c:expr:`PyObject*` parameters (the instance and
-   the value to be set) and a function pointer (the associated ``closure``)::
+.. c:type:: int (*setter)(PyObject *, PyObject *, void *)
 
-      typedef int (*setter)(PyObject *, PyObject *, void *);
+   ``set`` functions take two :c:expr:`PyObject*` parameters (the instance and
+   the value to be set) and a function pointer (the associated ``closure``):
 
    In case the attribute should be deleted the second parameter is ``NULL``.
    Should return ``0`` on success or ``-1`` with a set exception on failure.

Doc/library/concurrent.futures.rst

@@ -275,7 +275,8 @@ to a :class:`ProcessPoolExecutor` will result in deadlock.
 
    .. versionchanged:: 3.3
       When one of the worker processes terminates abruptly, a
-      :exc:`BrokenProcessPool` error is now raised.  Previously, behaviour
+      :exc:`~concurrent.futures.process.BrokenProcessPool` error is now raised.
+      Previously, behaviour
       was undefined but operations on the executor or its futures would often
       freeze or deadlock.
 
@@ -493,23 +494,22 @@ Module Functions
    *return_when* indicates when this function should return.  It must be one of
    the following constants:
 
-   .. tabularcolumns:: |l|L|
-
-   +-----------------------------+----------------------------------------+
-   | Constant                    | Description                            |
-   +=============================+========================================+
-   | :const:`FIRST_COMPLETED`    | The function will return when any      |
-   |                             | future finishes or is cancelled.       |
-   +-----------------------------+----------------------------------------+
-   | :const:`FIRST_EXCEPTION`    | The function will return when any      |
-   |                             | future finishes by raising an          |
-   |                             | exception.  If no future raises an     |
-   |                             | exception then it is equivalent to     |
-   |                             | :const:`ALL_COMPLETED`.                |
-   +-----------------------------+----------------------------------------+
-   | :const:`ALL_COMPLETED`      | The function will return when all      |
-   |                             | futures finish or are cancelled.       |
-   +-----------------------------+----------------------------------------+
+   .. list-table::
+      :header-rows: 1
+
+      * - Constant
+        - Description
+
+      * - .. data:: FIRST_COMPLETED
+        - The function will return when any future finishes or is cancelled.
+
+      * - .. data:: FIRST_EXCEPTION
+        - The function will return when any future finishes by raising an
+          exception. If no future raises an exception
+          then it is equivalent to :const:`ALL_COMPLETED`.
+
+      * - .. data:: ALL_COMPLETED
+        - The function will return when all futures finish or are cancelled.
 
 .. function:: as_completed(fs, timeout=None)
 
@@ -570,7 +570,8 @@ Exception classes
 .. exception:: BrokenThreadPool
 
    Derived from :exc:`~concurrent.futures.BrokenExecutor`, this exception
-   class is raised when one of the workers of a :class:`ThreadPoolExecutor`
+   class is raised when one of the workers
+   of a :class:`~concurrent.futures.ThreadPoolExecutor`
    has failed initializing.
 
    .. versionadded:: 3.7
@@ -581,7 +582,8 @@ Exception classes
 
    Derived from :exc:`~concurrent.futures.BrokenExecutor` (formerly
    :exc:`RuntimeError`), this exception class is raised when one of the
-   workers of a :class:`ProcessPoolExecutor` has terminated in a non-clean
+   workers of a :class:`~concurrent.futures.ProcessPoolExecutor`
+   has terminated in a non-clean
    fashion (for example, if it was killed from the outside).
 
    .. versionadded:: 3.3

Doc/library/dis.rst

@@ -546,8 +546,8 @@ operations on it as if it was a Python list. The top of the stack corresponds to
 
 .. opcode:: END_FOR
 
-   Removes the top two values from the stack.
-   Equivalent to ``POP_TOP``; ``POP_TOP``.
+   Removes the top-of-stack item.
+   Equivalent to ``POP_TOP``.
    Used to clean up at the end of loops, hence the name.
 
    .. versionadded:: 3.12

Doc/library/ftplib.rst

@@ -78,6 +78,9 @@ FTP objects
    A 2-tuple ``(host, port)`` for the socket to bind to as its
    source address before connecting.
 
+.. |param_doc_encoding| replace::
+   The encoding for directories and filenames (default: ``'utf-8'``).
+
 .. class:: FTP(host='', user='', passwd='', acct='', timeout=None, \
                source_address=None, *, encoding='utf-8')
 
@@ -108,8 +111,7 @@ FTP objects
    :type source_address: tuple | None
 
    :param str encoding:
-      The *encoding* parameter specifies the encoding
-      for directories and filenames.
+      |param_doc_encoding|
 
    The :class:`FTP` class supports the :keyword:`with` statement, e.g.:
 
@@ -447,19 +449,53 @@ FTP_TLS objects
 .. class:: FTP_TLS(host='', user='', passwd='', acct='', *, context=None, \
                    timeout=None, source_address=None, encoding='utf-8')
 
-   A :class:`FTP` subclass which adds TLS support to FTP as described in
+   An :class:`FTP` subclass which adds TLS support to FTP as described in
    :rfc:`4217`.
-   Connect as usual to port 21 implicitly securing the FTP control connection
-   before authenticating. Securing the data connection requires the user to
-   explicitly ask for it by calling the :meth:`prot_p` method.  *context*
-   is a :class:`ssl.SSLContext` object which allows bundling SSL configuration
-   options, certificates and private keys into a single (potentially
-   long-lived) structure.  Please read :ref:`ssl-security` for best practices.
+   Connect to port 21 implicitly securing the FTP control connection
+   before authenticating.
+
+   .. note::
+      The user must explicitly secure the data connection
+      by calling the :meth:`prot_p` method.
+
+   :param str host:
+      The hostname to connect to.
+      If given, :code:`connect(host)` is implicitly called by the constructor.
+
+   :param str user:
+      |param_doc_user|
+      If given, :code:`login(host, passwd, acct)` is implicitly called
+      by the constructor.
+
+   :param str passwd:
+      |param_doc_passwd|
+
+   :param str acct:
+      |param_doc_acct|
+
+   :param context:
+      An SSL context object which allows bundling SSL configuration options,
+      certificates and private keys into a single, potentially long-lived,
+      structure.
+      Please read :ref:`ssl-security` for best practices.
+   :type context: :class:`ssl.SSLContext`
+
+   :param timeout:
+      A timeout in seconds for blocking operations like :meth:`~FTP.connect`
+      (default: the global default timeout setting).
+   :type timeout: int | None
+
+   :param source_address:
+      |param_doc_source_address|
+   :type source_address: tuple | None
+
+   :param str encoding:
+      |param_doc_encoding|
 
    .. versionadded:: 3.2
 
    .. versionchanged:: 3.3
-      *source_address* parameter was added.
+      Added the *source_address* parameter.
 
    .. versionchanged:: 3.4
       The class now supports hostname check with

Doc/library/glob.rst

@@ -147,8 +147,9 @@ The :mod:`glob` module defines the following functions:
 
    .. seealso::
 
-     :meth:`pathlib.PurePath.match` and :meth:`pathlib.Path.glob` methods,
-     which call this function to implement pattern matching and globbing.
+     :meth:`pathlib.PurePath.full_match` and :meth:`pathlib.Path.glob`
+     methods, which call this function to implement pattern matching and
+     globbing.
 
    .. versionadded:: 3.13
 

Doc/library/pathlib.rst

@@ -559,55 +559,55 @@ Pure paths provide the following methods and properties:
       PureWindowsPath('c:/Program Files')
 
 
-.. method:: PurePath.match(pattern, *, case_sensitive=None)
+.. method:: PurePath.full_match(pattern, *, case_sensitive=None)
 
    Match this path against the provided glob-style pattern.  Return ``True``
-   if matching is successful, ``False`` otherwise.
-
-   If *pattern* is relative, the path can be either relative or absolute,
-   and matching is done from the right::
+   if matching is successful, ``False`` otherwise.  For example::
 
-      >>> PurePath('a/b.py').match('*.py')
-      True
-      >>> PurePath('/a/b/c.py').match('b/*.py')
+      >>> PurePath('a/b.py').full_match('a/*.py')
       True
-      >>> PurePath('/a/b/c.py').match('a/*.py')
+      >>> PurePath('a/b.py').full_match('*.py')
       False
+      >>> PurePath('/a/b/c.py').full_match('/a/**')
+      True
+      >>> PurePath('/a/b/c.py').full_match('**/*.py')
+      True
 
-   If *pattern* is absolute, the path must be absolute, and the whole path
-   must match::
+   As with other methods, case-sensitivity follows platform defaults::
 
-      >>> PurePath('/a.py').match('/*.py')
-      True
-      >>> PurePath('a/b.py').match('/*.py')
+      >>> PurePosixPath('b.py').full_match('*.PY')
       False
+      >>> PureWindowsPath('b.py').full_match('*.PY')
+      True
 
-   The *pattern* may be another path object; this speeds up matching the same
-   pattern against multiple files::
+   Set *case_sensitive* to ``True`` or ``False`` to override this behaviour.
 
-      >>> pattern = PurePath('*.py')
-      >>> PurePath('a/b.py').match(pattern)
-      True
+   .. versionadded:: 3.13
 
-   .. versionchanged:: 3.12
-      Accepts an object implementing the :class:`os.PathLike` interface.
 
-   As with other methods, case-sensitivity follows platform defaults::
+.. method:: PurePath.match(pattern, *, case_sensitive=None)
 
-      >>> PurePosixPath('b.py').match('*.PY')
-      False
-      >>> PureWindowsPath('b.py').match('*.PY')
+   Match this path against the provided non-recursive glob-style pattern.
+   Return ``True`` if matching is successful, ``False`` otherwise.
+
+   This method is similar to :meth:`~PurePath.full_match`, but empty patterns
+   aren't allowed (:exc:`ValueError` is raised), the recursive wildcard
+   "``**``" isn't supported (it acts like non-recursive "``*``"), and if a
+   relative pattern is provided, then matching is done from the right::
+
+      >>> PurePath('a/b.py').match('*.py')
+      True
+      >>> PurePath('/a/b/c.py').match('b/*.py')
       True
+      >>> PurePath('/a/b/c.py').match('a/*.py')
+      False
 
-   Set *case_sensitive* to ``True`` or ``False`` to override this behaviour.
+   .. versionchanged:: 3.12
+      The *pattern* parameter accepts a :term:`path-like object`.
 
    .. versionchanged:: 3.12
       The *case_sensitive* parameter was added.
 
-   .. versionchanged:: 3.13
-      Support for the recursive wildcard "``**``" was added. In previous
-      versions, it acted like the non-recursive wildcard "``*``".
-
 
 .. method:: PurePath.relative_to(other, walk_up=False)
 

Doc/library/ssl.rst

@@ -2574,12 +2574,8 @@ provided.
      :exc:`SSLWantReadError` if it needs more data than the incoming BIO has
      available.
 
-   - There is no module-level ``wrap_bio()`` call like there is for
-     :meth:`~SSLContext.wrap_socket`. An :class:`SSLObject` is always created
-     via an :class:`SSLContext`.
-
    .. versionchanged:: 3.7
-      :class:`SSLObject` instances must to created with
+      :class:`SSLObject` instances must be created with
       :meth:`~SSLContext.wrap_bio`. In earlier versions, it was possible to
       create instances directly. This was never documented or officially
       supported.

Doc/library/sys.monitoring.rst

@@ -75,9 +75,6 @@ following IDs are pre-defined to make co-operation of tools easier::
   sys.monitoring.PROFILER_ID = 2
   sys.monitoring.OPTIMIZER_ID = 5
 
-There is no obligation to set an ID, nor is there anything preventing a tool
-from using an ID even it is already in use.
-However, tools are encouraged to use a unique ID and respect other tools.
 
 Events
 ------

Doc/library/threading.rst

@@ -534,9 +534,10 @@ All methods are executed atomically.
    lock, subsequent attempts to acquire it block, until it is released; any
    thread may release it.
 
-   Note that ``Lock`` is actually a factory function which returns an instance
-   of the most efficient version of the concrete Lock class that is supported
-   by the platform.
+   .. versionchanged:: 3.13
+      ``Lock`` is now a class. In earlier Pythons, ``Lock`` was a factory
+      function which returned an instance of the underlying private lock
+      type.
 
 
    .. method:: acquire(blocking=True, timeout=-1)