@@ -9,6 +9,7 @@ VENVDIR      = ./venv
 SPHINXBUILD  = PATH=$(VENVDIR)/bin:$$PATH sphinx-build
 SPHINXLINT   = PATH=$(VENVDIR)/bin:$$PATH sphinx-lint
 BLURB        = PATH=$(VENVDIR)/bin:$$PATH blurb
+JOBS         = auto
 PAPER        =
 SOURCES      =
 DISTVERSION  = $(shell $(PYTHON) tools/extensions/patchlevel.py)
@@ -18,7 +19,7 @@ SPHINXERRORHANDLING = -W
 PAPEROPT_a4     = -D latex_elements.papersize=a4paper
 PAPEROPT_letter = -D latex_elements.papersize=letterpaper
 
-ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees $(PAPEROPT_$(PAPER)) -j auto \
+ALLSPHINXOPTS = -b $(BUILDER) -d build/doctrees $(PAPEROPT_$(PAPER)) -j $(JOBS) \
                 $(SPHINXOPTS) $(SPHINXERRORHANDLING) . build/$(BUILDER) $(SOURCES)
 
 .PHONY: help
 
@@ -77,6 +77,8 @@ bound into a function.
 
    Returns ``1`` if the function succeeds and 0 otherwise.
 
+   .. versionadded:: 3.11
+
 .. c:function:: PyObject* PyCode_GetCode(PyCodeObject *co)
 
    Equivalent to the Python code ``getattr(co, 'co_code')``.
 
@@ -248,8 +248,8 @@ Are there any published articles about Python that I can reference?
 
 It's probably best to cite your favorite book about Python.
 
-The very first article about Python was written in 1991 and is now quite
-outdated.
+The `very first article <https://ir.cwi.nl/pub/18204>`_ about Python was
+written in 1991 and is now quite outdated.
 
     Guido van Rossum and Jelke de Boer, "Interactively Testing Remote Servers
     Using the Python Programming Language", CWI Quarterly, Volume 4, Issue 4
 
@@ -307,7 +307,7 @@ Suppose you configure logging with the following JSON:
                 "class": "logging.StreamHandler",
                 "level": "INFO",
                 "formatter": "simple",
-                "stream": "ext://sys.stdout",
+                "stream": "ext://sys.stdout"
             },
             "stderr": {
                 "class": "logging.StreamHandler",
 
@@ -31,7 +31,7 @@ Core Functionality
 
 The :mod:`argparse` module's support for command-line interfaces is built
 around an instance of :class:`argparse.ArgumentParser`.  It is a container for
-argument specifications and has options that apply the parser as whole::
+argument specifications and has options that apply to the parser as whole::
 
    parser = argparse.ArgumentParser(
                        prog = 'ProgramName',
 
@@ -60,7 +60,7 @@ Notes:
 
 The actual representation of values is determined by the machine architecture
 (strictly speaking, by the C implementation).  The actual size can be accessed
-through the :attr:`itemsize` attribute.
+through the :attr:`array.itemsize` attribute.
 
 The module defines the following item:
 
@@ -85,161 +85,160 @@ The module defines the following type:
    to add initial items to the array.  Otherwise, the iterable initializer is
    passed to the :meth:`extend` method.
 
-   .. audit-event:: array.__new__ typecode,initializer array.array
+   Array objects support the ordinary sequence operations of indexing, slicing,
+   concatenation, and multiplication.  When using slice assignment, the assigned
+   value must be an array object with the same type code; in all other cases,
+   :exc:`TypeError` is raised. Array objects also implement the buffer interface,
+   and may be used wherever :term:`bytes-like objects <bytes-like object>` are supported.
 
+   .. audit-event:: array.__new__ typecode,initializer array.array
 
-Array objects support the ordinary sequence operations of indexing, slicing,
-concatenation, and multiplication.  When using slice assignment, the assigned
-value must be an array object with the same type code; in all other cases,
-:exc:`TypeError` is raised. Array objects also implement the buffer interface,
-and may be used wherever :term:`bytes-like objects <bytes-like object>` are supported.
 
-The following data items and methods are also supported:
+   .. attribute:: typecode
 
-.. attribute:: array.typecode
+      The typecode character used to create the array.
 
-   The typecode character used to create the array.
 
+   .. attribute:: itemsize
 
-.. attribute:: array.itemsize
+      The length in bytes of one array item in the internal representation.
 
-   The length in bytes of one array item in the internal representation.
 
+   .. method:: append(x)
 
-.. method:: array.append(x)
+      Append a new item with value *x* to the end of the array.
 
-   Append a new item with value *x* to the end of the array.
 
+   .. method:: buffer_info()
 
-.. method:: array.buffer_info()
+      Return a tuple ``(address, length)`` giving the current memory address and the
+      length in elements of the buffer used to hold array's contents.  The size of the
+      memory buffer in bytes can be computed as ``array.buffer_info()[1] *
+      array.itemsize``.  This is occasionally useful when working with low-level (and
+      inherently unsafe) I/O interfaces that require memory addresses, such as certain
+      :c:func:`!ioctl` operations.  The returned numbers are valid as long as the array
+      exists and no length-changing operations are applied to it.
 
-   Return a tuple ``(address, length)`` giving the current memory address and the
-   length in elements of the buffer used to hold array's contents.  The size of the
-   memory buffer in bytes can be computed as ``array.buffer_info()[1] *
-   array.itemsize``.  This is occasionally useful when working with low-level (and
-   inherently unsafe) I/O interfaces that require memory addresses, such as certain
-   :c:func:`ioctl` operations.  The returned numbers are valid as long as the array
-   exists and no length-changing operations are applied to it.
+      .. note::
 
-   .. note::
+         When using array objects from code written in C or C++ (the only way to
+         effectively make use of this information), it makes more sense to use the buffer
+         interface supported by array objects.  This method is maintained for backward
+         compatibility and should be avoided in new code.  The buffer interface is
+         documented in :ref:`bufferobjects`.
 
-      When using array objects from code written in C or C++ (the only way to
-      effectively make use of this information), it makes more sense to use the buffer
-      interface supported by array objects.  This method is maintained for backward
-      compatibility and should be avoided in new code.  The buffer interface is
-      documented in :ref:`bufferobjects`.
 
+   .. method:: byteswap()
 
-.. method:: array.byteswap()
+      "Byteswap" all items of the array.  This is only supported for values which are
+      1, 2, 4, or 8 bytes in size; for other types of values, :exc:`RuntimeError` is
+      raised.  It is useful when reading data from a file written on a machine with a
+      different byte order.
 
-   "Byteswap" all items of the array.  This is only supported for values which are
-   1, 2, 4, or 8 bytes in size; for other types of values, :exc:`RuntimeError` is
-   raised.  It is useful when reading data from a file written on a machine with a
-   different byte order.
 
+   .. method:: count(x)
 
-.. method:: array.count(x)
+      Return the number of occurrences of *x* in the array.
 
-   Return the number of occurrences of *x* in the array.
 
+   .. method:: extend(iterable)
 
-.. method:: array.extend(iterable)
+      Append items from *iterable* to the end of the array.  If *iterable* is another
+      array, it must have *exactly* the same type code; if not, :exc:`TypeError` will
+      be raised.  If *iterable* is not an array, it must be iterable and its elements
+      must be the right type to be appended to the array.
 
-   Append items from *iterable* to the end of the array.  If *iterable* is another
-   array, it must have *exactly* the same type code; if not, :exc:`TypeError` will
-   be raised.  If *iterable* is not an array, it must be iterable and its elements
-   must be the right type to be appended to the array.
 
+   .. method:: frombytes(s)
 
-.. method:: array.frombytes(s)
+      Appends items from the string, interpreting the string as an array of machine
+      values (as if it had been read from a file using the :meth:`fromfile` method).
 
-   Appends items from the string, interpreting the string as an array of machine
-   values (as if it had been read from a file using the :meth:`fromfile` method).
+      .. versionadded:: 3.2
+         :meth:`!fromstring` is renamed to :meth:`frombytes` for clarity.
 
-   .. versionadded:: 3.2
-      :meth:`fromstring` is renamed to :meth:`frombytes` for clarity.
 
+   .. method:: fromfile(f, n)
 
-.. method:: array.fromfile(f, n)
+      Read *n* items (as machine values) from the :term:`file object` *f* and append
+      them to the end of the array.  If less than *n* items are available,
+      :exc:`EOFError` is raised, but the items that were available are still
+      inserted into the array.
 
-   Read *n* items (as machine values) from the :term:`file object` *f* and append
-   them to the end of the array.  If less than *n* items are available,
-   :exc:`EOFError` is raised, but the items that were available are still
-   inserted into the array.
 
+   .. method:: fromlist(list)
 
-.. method:: array.fromlist(list)
+      Append items from the list.  This is equivalent to ``for x in list:
+      a.append(x)`` except that if there is a type error, the array is unchanged.
 
-   Append items from the list.  This is equivalent to ``for x in list:
-   a.append(x)`` except that if there is a type error, the array is unchanged.
 
+   .. method:: fromunicode(s)
 
-.. method:: array.fromunicode(s)
+      Extends this array with data from the given unicode string.  The array must
+      be a type ``'u'`` array; otherwise a :exc:`ValueError` is raised.  Use
+      ``array.frombytes(unicodestring.encode(enc))`` to append Unicode data to an
+      array of some other type.
 
-   Extends this array with data from the given unicode string.  The array must
-   be a type ``'u'`` array; otherwise a :exc:`ValueError` is raised.  Use
-   ``array.frombytes(unicodestring.encode(enc))`` to append Unicode data to an
-   array of some other type.
 
+   .. method:: index(x[, start[, stop]])
 
-.. method:: array.index(x[, start[, stop]])
+      Return the smallest *i* such that *i* is the index of the first occurrence of
+      *x* in the array.  The optional arguments *start* and *stop* can be
+      specified to search for *x* within a subsection of the array.  Raise
+      :exc:`ValueError` if *x* is not found.
 
-   Return the smallest *i* such that *i* is the index of the first occurrence of
-   *x* in the array.  The optional arguments *start* and *stop* can be
-   specified to search for *x* within a subsection of the array.  Raise
-   :exc:`ValueError` if *x* is not found.
+      .. versionchanged:: 3.10
+         Added optional *start* and *stop* parameters.
 
-   .. versionchanged:: 3.10
-      Added optional *start* and *stop* parameters.
 
-.. method:: array.insert(i, x)
+   .. method:: insert(i, x)
 
-   Insert a new item with value *x* in the array before position *i*. Negative
-   values are treated as being relative to the end of the array.
+      Insert a new item with value *x* in the array before position *i*. Negative
+      values are treated as being relative to the end of the array.
 
 
-.. method:: array.pop([i])
+   .. method:: pop([i])
 
-   Removes the item with the index *i* from the array and returns it. The optional
-   argument defaults to ``-1``, so that by default the last item is removed and
-   returned.
+      Removes the item with the index *i* from the array and returns it. The optional
+      argument defaults to ``-1``, so that by default the last item is removed and
+      returned.
 
 
-.. method:: array.remove(x)
+   .. method:: remove(x)
 
-   Remove the first occurrence of *x* from the array.
+      Remove the first occurrence of *x* from the array.
 
 
-.. method:: array.reverse()
+   .. method:: reverse()
 
-   Reverse the order of the items in the array.
+      Reverse the order of the items in the array.
 
 
-.. method:: array.tobytes()
+   .. method:: tobytes()
 
-   Convert the array to an array of machine values and return the bytes
-   representation (the same sequence of bytes that would be written to a file by
-   the :meth:`tofile` method.)
+      Convert the array to an array of machine values and return the bytes
+      representation (the same sequence of bytes that would be written to a file by
+      the :meth:`tofile` method.)
 
-   .. versionadded:: 3.2
-      :meth:`tostring` is renamed to :meth:`tobytes` for clarity.
+      .. versionadded:: 3.2
+         :meth:`!tostring` is renamed to :meth:`tobytes` for clarity.
 
 
-.. method:: array.tofile(f)
+   .. method:: tofile(f)
 
-   Write all items (as machine values) to the :term:`file object` *f*.
+      Write all items (as machine values) to the :term:`file object` *f*.
 
 
-.. method:: array.tolist()
+   .. method:: tolist()
 
-   Convert the array to an ordinary list with the same items.
+      Convert the array to an ordinary list with the same items.
 
 
-.. method:: array.tounicode()
+   .. method:: tounicode()
 
-   Convert the array to a unicode string.  The array must be a type ``'u'`` array;
-   otherwise a :exc:`ValueError` is raised. Use ``array.tobytes().decode(enc)`` to
-   obtain a unicode string from an array of some other type.
+      Convert the array to a unicode string.  The array must be a type ``'u'`` array;
+      otherwise a :exc:`ValueError` is raised. Use ``array.tobytes().decode(enc)`` to
+      obtain a unicode string from an array of some other type.
 
 
 When an array object is printed or converted to a string, it is represented as
 
@@ -295,7 +295,8 @@ StreamWriter
 
       The method closes the stream and the underlying socket.
 
-      The method should be used along with the ``wait_closed()`` method::
+      The method should be used, though not mandatory,
+      along with the ``wait_closed()`` method::
 
          stream.close()
          await stream.wait_closed()
@@ -335,7 +336,7 @@ StreamWriter
       returns immediately.
 
    .. coroutinemethod:: start_tls(sslcontext, \*, server_hostname=None, \
-                          ssl_handshake_timeout=None)
+                          ssl_handshake_timeout=None, ssl_shutdown_timeout=None)
 
       Upgrade an existing stream-based connection to TLS.
 
@@ -350,8 +351,16 @@ StreamWriter
         handshake to complete before aborting the connection.  ``60.0`` seconds
         if ``None`` (default).
 
+      * *ssl_shutdown_timeout* is the time in seconds to wait for the SSL shutdown
+        to complete before aborting the connection. ``30.0`` seconds if ``None``
+        (default).
+
       .. versionadded:: 3.11
 
+      .. versionchanged:: 3.12
+         Added the *ssl_shutdown_timeout* parameter.
+
+
    .. method:: is_closing()
 
       Return ``True`` if the stream is closed or in the process of
@@ -364,7 +373,8 @@ StreamWriter
       Wait until the stream is closed.
 
       Should be called after :meth:`close` to wait until the underlying
-      connection is closed.
+      connection is closed, ensuring that all data has been flushed
+      before e.g. exiting the program.
 
       .. versionadded:: 3.7
 
@@ -394,6 +404,7 @@ TCP echo client using the :func:`asyncio.open_connection` function::
 
         print('Close the connection')
         writer.close()
+        await writer.wait_closed()
 
     asyncio.run(tcp_echo_client('Hello World!'))
 
@@ -426,6 +437,7 @@ TCP echo server using the :func:`asyncio.start_server` function::
 
         print("Close the connection")
         writer.close()
+        await writer.wait_closed()
 
     async def main():
         server = await asyncio.start_server(
@@ -482,6 +494,7 @@ Simple example querying HTTP headers of the URL passed on the command line::
 
         # Ignore the body, close the socket
         writer.close()
+        await writer.wait_closed()
 
     url = sys.argv[1]
     asyncio.run(print_http_headers(url))
@@ -527,6 +540,7 @@ Coroutine waiting until a socket receives data using the
         # Got data, we are done: close the socket
         print("Received:", data.decode())
         writer.close()
+        await writer.wait_closed()
 
         # Close the second socket
         wsock.close()