Merge branch 'python:main' into patch-1

Author: sharktide

Doc/library/concurrent.futures.rst

@@ -415,30 +415,6 @@ to a :class:`ProcessPoolExecutor` will result in deadlock.
       require the *fork* start method for :class:`ProcessPoolExecutor` you must
       explicitly pass ``mp_context=multiprocessing.get_context("fork")``.
 
-   .. method:: terminate_workers()
-
-      Attempt to terminate all living worker processes immediately by calling
-      :meth:`Process.terminate <multiprocessing.Process.terminate>` on each of them.
-      Internally, it will also call :meth:`Executor.shutdown` to ensure that all
-      other resources associated with the executor are freed.
-
-      After calling this method the caller should no longer submit tasks to the
-      executor.
-
-      .. versionadded:: next
-
-   .. method:: kill_workers()
-
-      Attempt to kill all living worker processes immediately by calling
-      :meth:`Process.kill <multiprocessing.Process.kill>` on each of them.
-      Internally, it will also call :meth:`Executor.shutdown` to ensure that all
-      other resources associated with the executor are freed.
-
-      After calling this method the caller should no longer submit tasks to the
-      executor.
-
-      .. versionadded:: next
-
 .. _processpoolexecutor-example:
 
 ProcessPoolExecutor Example

Doc/library/typing.rst

@@ -2551,15 +2551,20 @@ types.
 
    This functional syntax allows defining keys which are not valid
    :ref:`identifiers <identifiers>`, for example because they are
-   keywords or contain hyphens::
+   keywords or contain hyphens, or when key names must not be
+   :ref:`mangled <private-name-mangling>` like regular private names::
 
       # raises SyntaxError
       class Point2D(TypedDict):
           in: int  # 'in' is a keyword
           x-y: int  # name with hyphens
 
+      class Definition(TypedDict):
+          __schema: str  # mangled to `_Definition__schema`
+
       # OK, functional syntax
       Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})
+      Definition = TypedDict('Definition', {'__schema': str})  # not mangled
 
    By default, all keys must be present in a ``TypedDict``. It is possible to
    mark individual keys as non-required using :data:`NotRequired`::

Doc/whatsnew/3.14.rst

@@ -444,11 +444,6 @@ contextvars
 * Support context manager protocol by :class:`contextvars.Token`.
   (Contributed by Andrew Svetlov in :gh:`129889`.)
 
-* Add :meth:`concurrent.futures.ProcessPoolExecutor.terminate_workers` and
-  :meth:`concurrent.futures.ProcessPoolExecutor.kill_workers` as
-  ways to terminate or kill all living worker processes in the given pool.
-  (Contributed by Charles Machalow in :gh:`128043`.)
-
 
 ctypes
 ------

Lib/concurrent/futures/process.py

@@ -626,14 +626,6 @@ class BrokenProcessPool(_base.BrokenExecutor):
     while a future was in the running state.
     """
 
-_TERMINATE = "terminate"
-_KILL = "kill"
-
-_SHUTDOWN_CALLBACK_OPERATION = {
-    _TERMINATE,
-    _KILL
-}
-
 
 class ProcessPoolExecutor(_base.Executor):
     def __init__(self, max_workers=None, mp_context=None,
@@ -863,66 +855,3 @@ def shutdown(self, wait=True, *, cancel_futures=False):
         self._executor_manager_thread_wakeup = None
 
     shutdown.__doc__ = _base.Executor.shutdown.__doc__
-
-    def _force_shutdown(self, operation):
-        """Attempts to terminate or kill the executor's workers based off the
-        given operation. Iterates through all of the current processes and
-        performs the relevant task if the process is still alive.
-
-        After terminating workers, the pool will be in a broken state
-        and no longer usable (for instance, new tasks should not be
-        submitted).
-        """
-        if operation not in _SHUTDOWN_CALLBACK_OPERATION:
-            raise ValueError(f"Unsupported operation: {operation!r}")
-
-        processes = {}
-        if self._processes:
-            processes = self._processes.copy()
-
-        # shutdown will invalidate ._processes, so we copy it right before
-        # calling. If we waited here, we would deadlock if a process decides not
-        # to exit.
-        self.shutdown(wait=False, cancel_futures=True)
-
-        if not processes:
-            return
-
-        for proc in processes.values():
-            try:
-                if not proc.is_alive():
-                    continue
-            except ValueError:
-                # The process is already exited/closed out.
-                continue
-
-            try:
-                if operation == _TERMINATE:
-                    proc.terminate()
-                elif operation == _KILL:
-                    proc.kill()
-            except ProcessLookupError:
-                # The process just ended before our signal
-                continue
-
-    def terminate_workers(self):
-        """Attempts to terminate the executor's workers.
-        Iterates through all of the current worker processes and terminates
-        each one that is still alive.
-
-        After terminating workers, the pool will be in a broken state
-        and no longer usable (for instance, new tasks should not be
-        submitted).
-        """
-        return self._force_shutdown(operation=_TERMINATE)
-
-    def kill_workers(self):
-        """Attempts to kill the executor's workers.
-        Iterates through all of the current worker processes and kills
-        each one that is still alive.
-
-        After killing workers, the pool will be in a broken state
-        and no longer usable (for instance, new tasks should not be
-        submitted).
-        """
-        return self._force_shutdown(operation=_KILL)

Lib/dataclasses.py

@@ -1163,7 +1163,10 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
         try:
             # In some cases fetching a signature is not possible.
             # But, we surely should not fail in this case.
-            text_sig = str(inspect.signature(cls)).replace(' -> None', '')
+            text_sig = str(inspect.signature(
+                cls,
+                annotation_format=annotationlib.Format.FORWARDREF,
+            )).replace(' -> None', '')
         except (TypeError, ValueError):
             text_sig = ''
         cls.__doc__ = (cls.__name__ + text_sig)

Lib/inspect.py

@@ -143,7 +143,7 @@
 
 
 import abc
-from annotationlib import Format
+from annotationlib import Format, ForwardRef
 from annotationlib import get_annotations  # re-exported
 import ast
 import dis
@@ -1342,6 +1342,8 @@ def repl(match):
         if annotation.__module__ in ('builtins', base_module):
             return annotation.__qualname__
         return annotation.__module__+'.'+annotation.__qualname__
+    if isinstance(annotation, ForwardRef):
+        return annotation.__forward_arg__
     return repr(annotation)
 
 def formatannotationrelativeto(object):

Lib/test/test_concurrent_futures/test_process_pool.py

@@ -1,17 +1,13 @@
 import os
-import queue
-import signal
 import sys
 import threading
 import time
 import unittest
-import unittest.mock
 from concurrent import futures
 from concurrent.futures.process import BrokenProcessPool
 
 from test import support
 from test.support import hashlib_helper
-from test.test_importlib.metadata.fixtures import parameterize
 
 from .executor import ExecutorTest, mul
 from .util import (
@@ -26,19 +22,6 @@ def __init__(self, mgr):
     def __del__(self):
         self.event.set()
 
-TERMINATE_WORKERS = futures.ProcessPoolExecutor.terminate_workers.__name__
-KILL_WORKERS = futures.ProcessPoolExecutor.kill_workers.__name__
-FORCE_SHUTDOWN_PARAMS = [
-    dict(function_name=TERMINATE_WORKERS),
-    dict(function_name=KILL_WORKERS),
-]
-
-def _put_sleep_put(queue):
-    """ Used as part of test_terminate_workers """
-    queue.put('started')
-    time.sleep(2)
-    queue.put('finished')
-
 
 class ProcessPoolExecutorTest(ExecutorTest):
 
@@ -235,86 +218,6 @@ def mock_start_new_thread(func, *args, **kwargs):
                     list(executor.map(mul, [(2, 3)] * 10))
             executor.shutdown()
 
-    def test_terminate_workers(self):
-        mock_fn = unittest.mock.Mock()
-        with self.executor_type(max_workers=1) as executor:
-            executor._force_shutdown = mock_fn
-            executor.terminate_workers()
-
-        mock_fn.assert_called_once_with(operation=futures.process._TERMINATE)
-
-    def test_kill_workers(self):
-        mock_fn = unittest.mock.Mock()
-        with self.executor_type(max_workers=1) as executor:
-            executor._force_shutdown = mock_fn
-            executor.kill_workers()
-
-        mock_fn.assert_called_once_with(operation=futures.process._KILL)
-
-    def test_force_shutdown_workers_invalid_op(self):
-        with self.executor_type(max_workers=1) as executor:
-            self.assertRaises(ValueError,
-                              executor._force_shutdown,
-                              operation='invalid operation'),
-
-    @parameterize(*FORCE_SHUTDOWN_PARAMS)
-    def test_force_shutdown_workers(self, function_name):
-        manager = self.get_context().Manager()
-        q = manager.Queue()
-
-        with self.executor_type(max_workers=1) as executor:
-            executor.submit(_put_sleep_put, q)
-
-            # We should get started, but not finished since we'll terminate the
-            # workers just after
-            self.assertEqual(q.get(timeout=5), 'started')
-
-            worker_process = list(executor._processes.values())[0]
-            getattr(executor, function_name)()
-            worker_process.join()
-
-            if function_name == TERMINATE_WORKERS or \
-                sys.platform == 'win32':
-                # On windows, kill and terminate both send SIGTERM
-                self.assertEqual(worker_process.exitcode, -signal.SIGTERM)
-            elif function_name == KILL_WORKERS:
-                self.assertEqual(worker_process.exitcode, -signal.SIGKILL)
-            else:
-                self.fail(f"Unknown operation: {function_name}")
-
-            self.assertRaises(queue.Empty, q.get, timeout=1)
-
-    @parameterize(*FORCE_SHUTDOWN_PARAMS)
-    def test_force_shutdown_workers_dead_workers(self, function_name):
-        with self.executor_type(max_workers=1) as executor:
-            future = executor.submit(os._exit, 1)
-            self.assertRaises(BrokenProcessPool, future.result)
-
-            # even though the pool is broken, this shouldn't raise
-            getattr(executor, function_name)()
-
-    @parameterize(*FORCE_SHUTDOWN_PARAMS)
-    def test_force_shutdown_workers_not_started_yet(self, function_name):
-        ctx = self.get_context()
-        with unittest.mock.patch.object(ctx, 'Process') as mock_process:
-            with self.executor_type(max_workers=1, mp_context=ctx) as executor:
-                # The worker has not been started yet, terminate/kill_workers
-                # should basically no-op
-                getattr(executor, function_name)()
-
-            mock_process.return_value.kill.assert_not_called()
-            mock_process.return_value.terminate.assert_not_called()
-
-    @parameterize(*FORCE_SHUTDOWN_PARAMS)
-    def test_force_shutdown_workers_stops_pool(self, function_name):
-        with self.executor_type(max_workers=1) as executor:
-            task = executor.submit(time.sleep, 0)
-            self.assertIsNone(task.result())
-
-            getattr(executor, function_name)()
-
-            self.assertRaises(RuntimeError, executor.submit, time.sleep, 0)
-
 
 create_executor_tests(globals(), ProcessPoolExecutorTest,
                       executor_mixins=(ProcessPoolForkMixin,

Lib/test/test_dataclasses/__init__.py

@@ -12,6 +12,7 @@
 import types
 import weakref
 import traceback
+import textwrap
 import unittest
 from unittest.mock import Mock
 from typing import ClassVar, Any, List, Union, Tuple, Dict, Generic, TypeVar, Optional, Protocol, DefaultDict
@@ -2343,6 +2344,31 @@ class C:
 
         self.assertDocStrEqual(C.__doc__, "C(x:collections.deque=<factory>)")
 
+    def test_docstring_undefined_name(self):
+        @dataclass
+        class C:
+            x: undef
+
+        self.assertDocStrEqual(C.__doc__, "C(x:undef)")
+
+    def test_docstring_with_unsolvable_forward_ref_in_init(self):
+        # See: https://github.com/python/cpython/issues/128184
+        ns = {}
+        exec(
+            textwrap.dedent(
+                """
+                from dataclasses import dataclass
+
+                @dataclass
+                class C:
+                    def __init__(self, x: X, num: int) -> None: ...
+                """,
+            ),
+            ns,
+        )
+
+        self.assertDocStrEqual(ns['C'].__doc__, "C(x:X,num:int)")
+
     def test_docstring_with_no_signature(self):
         # See https://github.com/python/cpython/issues/103449
         class Meta(type):

Lib/test/test_inspect/test_inspect.py

@@ -1753,6 +1753,10 @@ def test_typing_replacement(self):
         self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]')
         self.assertEqual(inspect.formatannotation(ann1), 'Union[List[testModule.typing.A], int]')
 
+    def test_forwardref(self):
+        fwdref = ForwardRef('fwdref')
+        self.assertEqual(inspect.formatannotation(fwdref), 'fwdref')
+
 
 class TestIsMethodDescriptor(unittest.TestCase):
 
@@ -4587,6 +4591,11 @@ def foo(a: list[str]) -> Tuple[str, float]:
         self.assertEqual(str(inspect.signature(foo)),
                          inspect.signature(foo).format())
 
+        def foo(x: undef):
+            pass
+        sig = inspect.signature(foo, annotation_format=Format.FORWARDREF)
+        self.assertEqual(str(sig), '(x: undef)')
+
     def test_signature_str_positional_only(self):
         P = inspect.Parameter
         S = inspect.Signature