Merge branch 'main' into frameobj

Author: lpyu001

Doc/library/asyncio-task.rst

@@ -924,6 +924,9 @@ Waiting primitives
    Unlike :func:`~asyncio.wait_for`, ``wait()`` does not cancel the
    futures when a timeout occurs.
 
+   If ``wait()`` is cancelled, the futures in *aws* are not cancelled
+   and continue to run.
+
    .. versionchanged:: 3.10
       Removed the *loop* parameter.
 
@@ -981,6 +984,10 @@ Waiting primitives
    are done. This is raised by the ``async for`` loop during asynchronous
    iteration or by the coroutines yielded during plain iteration.
 
+   ``as_completed()`` does not cancel the tasks running the supplied
+   awaitables: if a timeout occurs or the iteration is cancelled, the
+   remaining tasks continue to run.
+
    .. versionchanged:: 3.10
       Removed the *loop* parameter.
 

Doc/library/urllib.request.rst

@@ -1486,7 +1486,8 @@ some point in the future.
 .. function:: urlcleanup()
 
    Cleans up temporary files that may have been left behind by previous
-   calls to :func:`urlretrieve`.
+   calls to :func:`urlretrieve`.  It also resets the default global opener
+   installed by :func:`install_opener`.
 
 
 :mod:`!urllib.request` Restrictions

Doc/tutorial/introduction.rst

@@ -532,10 +532,13 @@ This example introduces several new features.
   and ``!=`` (not equal to).
 
 * The *body* of the loop is *indented*: indentation is Python's way of grouping
-  statements.  At the interactive prompt, you have to type a tab or space(s) for
-  each indented line.  In practice you will prepare more complicated input
-  for Python with a text editor; all decent text editors have an auto-indent
-  facility.  When a compound statement is entered interactively, it must be
+  statements.  At the interactive prompt, the default REPL automatically
+  indents continuation lines after compound statement headers like ``if`` or
+  ``while``.  In the basic REPL (invoked with :envvar:`PYTHON_BASIC_REPL`)
+  or in older Python versions, you have to type a tab or space(s) for each
+  indented line manually.  In practice you will prepare more complicated
+  input for Python with a text editor; all decent text editors have an
+  auto-indent facility.  When a compound statement is entered interactively, it must be
   followed by a blank line to indicate completion (since the parser cannot
   guess when you have typed the last line).  Note that each line within a basic
   block must be indented by the same amount.

Lib/_pyrepl/base_eventqueue.py

@@ -54,14 +54,6 @@ def empty(self) -> bool:
         """
         return not self.events
 
-    def flush_buf(self) -> bytearray:
-        """
-        Flushes the buffer and returns its contents.
-        """
-        old = self.buf
-        self.buf = bytearray()
-        return old
-
     def insert(self, event: Event) -> None:
         """
         Inserts an event into the queue.
@@ -87,7 +79,7 @@ def push(self, char: int | bytes) -> None:
             if isinstance(k, dict):
                 self.keymap = k
             else:
-                self.insert(Event('key', k, bytes(self.flush_buf())))
+                self.insert(Event('key', k, self.buf.take_bytes()))  # type: ignore[attr-defined]
                 self.keymap = self.compiled_keymap
 
         elif self.buf and self.buf[0] == 27:  # escape
@@ -97,14 +89,14 @@ def push(self, char: int | bytes) -> None:
             trace('unrecognized escape sequence, propagating...')
             self.keymap = self.compiled_keymap
             self.insert(Event('key', '\033', b'\033'))
-            for _c in self.flush_buf()[1:]:
+            for _c in self.buf.take_bytes()[1:]:  # type: ignore[attr-defined]
                 self.push(_c)
 
         else:
             try:
-                decoded = bytes(self.buf).decode(self.encoding)
+                decoded = self.buf.decode(self.encoding)
             except UnicodeError:
                 return
             else:
-                self.insert(Event('key', decoded, bytes(self.flush_buf())))
+                self.insert(Event('key', decoded, self.buf.take_bytes()))  # type: ignore[attr-defined]
             self.keymap = self.compiled_keymap

Lib/asyncio/selector_events.py

@@ -206,6 +206,7 @@ def _accept_connection(
                                     protocol_factory, sock, sslcontext, server,
                                     backlog, ssl_handshake_timeout,
                                     ssl_shutdown_timeout, context)
+                    return
                 else:
                     raise  # The event loop will catch, log and ignore it.
             else:

Lib/compression/zstd/_zstdfile.py

@@ -246,6 +246,7 @@ def peek(self, size=-1):
         return self._buffer.peek(size)
 
     def __next__(self):
+        self._check_can_read()
         if ret := self._buffer.readline():
             return ret
         raise StopIteration

Lib/profiling/sampling/live_collector/collector.py

@@ -702,6 +702,7 @@ def build_stats_list(self):
     def reset_stats(self):
         """Reset all collected statistics."""
         self.result.clear()
+        self.opcode_stats.clear()
         self.per_thread_data.clear()
         self.thread_ids.clear()
         self.view_mode = "ALL"

Lib/test/test_asyncio/test_selector_events.py

@@ -1,6 +1,7 @@
 """Tests for selector_events.py"""
 
 import collections
+import errno
 import selectors
 import socket
 import sys
@@ -402,6 +403,24 @@ def mock_sock_accept():
         self.loop.run_until_complete(asyncio.sleep(0))
         self.assertEqual(sock.accept.call_count, backlog + 1)
 
+    def test_accept_connection_reschedules_once_on_resource_error(self):
+        # When accept() fails with a resource error (EMFILE), _accept_connection
+        # re-runs the error branch backlog+1 times, logging and rescheduling
+        # _start_serving once per iteration. With early return after first
+        # exception we avoid this behaviour
+        sock = mock.Mock()
+        sock.accept.side_effect = OSError(errno.EMFILE, 'too many open files')
+
+        self.loop.call_exception_handler = mock.Mock()
+        self.loop._remove_reader = mock.Mock()
+        self.loop.call_later = mock.Mock()
+
+        self.loop._accept_connection(mock.Mock(), sock, backlog=100)
+
+        self.assertEqual(sock.accept.call_count, 1)
+        self.assertEqual(self.loop.call_exception_handler.call_count, 1)
+        self.assertEqual(self.loop.call_later.call_count, 1)
+
 class SelectorTransportTests(test_utils.TestCase):
 
     def setUp(self):

Lib/test/test_capi/test_run.py

@@ -310,13 +310,15 @@ def check_run_interactive(self, run, encode_filename, use_loop=False):
             # supported". In this case, run the test without redirecting
             # stderr to a temporary file.
             self._check_run_interactive(run, encode_filename, use_loop)
-        else:
-            with tempfile.TemporaryFile() as tmp:
-                try:
-                    os.dup2(tmp.fileno(), STDERR_FD)
-                    self._check_run_interactive(run, encode_filename, use_loop)
-                finally:
-                    os.dup2(stderr_copy, STDERR_FD)
+            return
+
+        with tempfile.TemporaryFile() as tmp:
+            try:
+                os.dup2(tmp.fileno(), STDERR_FD)
+                self._check_run_interactive(run, encode_filename, use_loop)
+            finally:
+                os.dup2(stderr_copy, STDERR_FD)
+                os.close(stderr_copy)
 
     def test_run_interactiveone(self):
         # Test PyRun_InteractiveOne()

Lib/test/test_fstring.py

@@ -709,6 +709,16 @@ def test_double_braces(self):
                             ["f'{ {{}} }'", # dict in a set
                              ])
 
+    def test_double_brace_ast_location_covers_both_source_braces(self):
+        value = ast.parse('f"a{{"').body[0].value.values[0]
+        self.assertIsInstance(value, ast.Constant)
+        self.assertEqual(value.value, "a{")
+        self.assertEqual(
+            (value.lineno, value.col_offset, value.end_lineno,
+             value.end_col_offset),
+            (1, 2, 1, 5),
+        )
+
     def test_compile_time_concat(self):
         x = 'def'
         self.assertEqual('abc' f'## {x}ghi', 'abc## defghi')