For now, drop support for scripts.

python · ericsnowcurrently · Oct 16, 2024 · Sep 25, 2024 · Sep 25, 2024 · Sep 27, 2024
commit a7f5c50e7c1032123d6816db614d34757d0472fc
diff --git a/Doc/library/concurrent.futures.rst b/Doc/library/concurrent.futures.rst
@@ -305,11 +305,6 @@ the bytes over a shared :mod:`socket <socket>` or
      The executor may replace uncaught exceptions from *initializer*
      with :class:`~concurrent.futures.interpreter.ExecutionFailed`.

-   The *initializer* argument may also be a script (:class:`str`),
-   The script will be executed in the interpreter's ``__main__`` module.
-   The executor automatically applies :func:`textwrap.dedent` to the script.
-   *initargs* must not be passed in in this case.
-
   The optional *shared* argument is a :class:`dict` of objects that all
   interpreters in the pool share.  The *shared* items are added to each
   interpreter's ``__main__`` module.  Not all objects are shareable.
@@ -328,13 +323,6 @@ likewise serializes the return value when sending it back.
   Functions defined in the ``__main__`` module cannot be pickled
   and thus cannot be used.

-For :meth:`~Executor.submit`, but *not* :meth:`~Executor.map`,
-you can also pass a script (:class:`str`) instead of a callable.
-The script will be executed in the interpreter's ``__main__`` module.
-The executor will automatically apply :func:`textwrap.dedent` to the
-script, so you don't have to do so.  With a script, arguments must
-not be passed in.  The return value for a script is always ``None``.
-
 When a worker's current task raises an uncaught exception, the worker
 always tries to preserve the exception as-is.  If that is successful
 then it also sets the ``__cause__`` to a corresponding

@@ -45,6 +45,8 @@ class WorkerContext(_thread.WorkerContext):
    def prepare(cls, initializer, initargs, shared):
        def resolve_task(fn, args, kwargs):
            if isinstance(fn, str):
+                # XXX Circle back to this later.
+                raise TypeError('scripts not supported')
                if args or kwargs:
                    raise ValueError(f'a script does not take args or kwargs, got {args!r} and {kwargs!r}')
                data = textwrap.dedent(fn)
@@ -60,11 +62,13 @@ def resolve_task(fn, args, kwargs):
                kind = 'function'
            return (data, kind)

-        if isinstance(initializer, str):
-            if initargs:
-                raise ValueError(f'an initializer script does not take args, got {initargs!r}')
        if initializer is not None:
-            initdata = resolve_task(initializer, initargs, {})
+            try:
+                initdata = resolve_task(initializer, initargs, {})
+            except ValueError:
+                if isinstance(initializer, str) and initargs:
+                    raise ValueError(f'an initializer script does not take args, got {initargs!r}')
+                raise  # re-raise
        else:
            initdata = None
        def create_context():
@@ -160,6 +164,7 @@ def finalize(self):
    def run(self, task):
        data, kind = task
        if kind == 'script':
+            raise NotImplementedError('script kind disabled')
            script = f"""
 with WorkerContext._capture_exc({self.resultsid}):
 {textwrap.indent(data, '    ')}

diff --git a/Lib/test/test_concurrent_futures/test_interpreter_pool.py b/Lib/test/test_concurrent_futures/test_interpreter_pool.py
@@ -18,6 +18,10 @@
 from .util import BaseTestCase, InterpreterPoolMixin, setup_module


+def noop():
+    pass
+
+
 def write_msg(fd, msg):
    os.write(fd, msg + b'\0')

@@ -55,6 +59,7 @@ def pipe(self):
 class InterpreterPoolExecutorTest(
            InterpretersMixin, ExecutorTest, BaseTestCase):

+    @unittest.expectedFailure
    def test_init_script(self):
        msg1 = b'step: init'
        msg2 = b'step: run'
@@ -80,6 +85,7 @@ def test_init_script(self):
        self.assertEqual(after_init, msg1)
        self.assertEqual(after_run, msg2)

+    @unittest.expectedFailure
    def test_init_script_args(self):
        with self.assertRaises(ValueError):
            self.executor_type(initializer='pass', initargs=('spam',))
@@ -123,46 +129,50 @@ def initializer(self):
    def test_init_shared(self):
        msg = b'eggs'
        r, w = self.pipe()
-        script = f"""
+        script = f"""if True:
            import os
+            if __name__ != '__main__':
+                import __main__
+                spam = __main__.spam
            os.write({w}, spam + b'\\0')
            """

        executor = self.executor_type(shared={'spam': msg})
-        fut = executor.submit(script)
+        fut = executor.submit(exec, script)
        fut.result()
        after = read_msg(r)

        self.assertEqual(after, msg)

-    def test_init_exception(self):
-        with self.subTest('script'):
-            executor = self.executor_type(initializer='raise Exception("spam")')
-            with executor:
-                with contextlib.redirect_stderr(io.StringIO()) as stderr:
-                    fut = executor.submit('pass')
-                    with self.assertRaises(BrokenInterpreterPool):
-                        fut.result()
-            stderr = stderr.getvalue()
-            self.assertIn('ExecutionFailed: Exception: spam', stderr)
-            self.assertIn('Uncaught in the interpreter:', stderr)
-            self.assertIn('The above exception was the direct cause of the following exception:',
-                          stderr)
-
-        with self.subTest('func'):
-            executor = self.executor_type(initializer=fail,
-                                          initargs=(Exception, 'spam'))
-            with executor:
-                with contextlib.redirect_stderr(io.StringIO()) as stderr:
-                    fut = executor.submit('pass')
-                    with self.assertRaises(BrokenInterpreterPool):
-                        fut.result()
-            stderr = stderr.getvalue()
-            self.assertIn('ExecutionFailed: Exception: spam', stderr)
-            self.assertIn('Uncaught in the interpreter:', stderr)
-            self.assertIn('The above exception was the direct cause of the following exception:',
-                          stderr)
-
+    @unittest.expectedFailure
+    def test_init_exception_in_script(self):
+        executor = self.executor_type(initializer='raise Exception("spam")')
+        with executor:
+            with contextlib.redirect_stderr(io.StringIO()) as stderr:
+                fut = executor.submit('pass')
+                with self.assertRaises(BrokenInterpreterPool):
+                    fut.result()
+        stderr = stderr.getvalue()
+        self.assertIn('ExecutionFailed: Exception: spam', stderr)
+        self.assertIn('Uncaught in the interpreter:', stderr)
+        self.assertIn('The above exception was the direct cause of the following exception:',
+                      stderr)
+
+    def test_init_exception_in_func(self):
+        executor = self.executor_type(initializer=fail,
+                                      initargs=(Exception, 'spam'))
+        with executor:
+            with contextlib.redirect_stderr(io.StringIO()) as stderr:
+                fut = executor.submit(noop)
+                with self.assertRaises(BrokenInterpreterPool):
+                    fut.result()
+        stderr = stderr.getvalue()
+        self.assertIn('ExecutionFailed: Exception: spam', stderr)
+        self.assertIn('Uncaught in the interpreter:', stderr)
+        self.assertIn('The above exception was the direct cause of the following exception:',
+                      stderr)
+
+    @unittest.expectedFailure
    def test_submit_script(self):
        msg = b'spam'
        r, w = self.pipe()
@@ -221,39 +231,40 @@ def test_submit_func_globals(self):
        self.assertEqual(name, __name__)
        self.assertNotEqual(name, '__main__')

-    def test_submit_exception(self):
-        with self.subTest('script'):
-            fut = self.executor.submit('raise Exception("spam")')
-            with self.assertRaises(Exception) as captured:
-                fut.result()
-            self.assertIs(type(captured.exception), Exception)
-            self.assertEqual(str(captured.exception), 'spam')
-            cause = captured.exception.__cause__
-            self.assertIs(type(cause), ExecutionFailed)
-            for attr in ('__name__', '__qualname__', '__module__'):
-                self.assertEqual(getattr(cause.excinfo.type, attr),
-                                 getattr(Exception, attr))
-            self.assertEqual(cause.excinfo.msg, 'spam')
-
-        with self.subTest('func'):
-            fut = self.executor.submit(fail, Exception, 'spam')
-            with self.assertRaises(Exception) as captured:
-                fut.result()
-            self.assertIs(type(captured.exception), Exception)
-            self.assertEqual(str(captured.exception), 'spam')
-            cause = captured.exception.__cause__
-            self.assertIs(type(cause), ExecutionFailed)
-            for attr in ('__name__', '__qualname__', '__module__'):
-                self.assertEqual(getattr(cause.excinfo.type, attr),
-                                 getattr(Exception, attr))
-            self.assertEqual(cause.excinfo.msg, 'spam')
+    @unittest.expectedFailure
+    def test_submit_exception_in_script(self):
+        fut = self.executor.submit('raise Exception("spam")')
+        with self.assertRaises(Exception) as captured:
+            fut.result()
+        self.assertIs(type(captured.exception), Exception)
+        self.assertEqual(str(captured.exception), 'spam')
+        cause = captured.exception.__cause__
+        self.assertIs(type(cause), ExecutionFailed)
+        for attr in ('__name__', '__qualname__', '__module__'):
+            self.assertEqual(getattr(cause.excinfo.type, attr),
+                             getattr(Exception, attr))
+        self.assertEqual(cause.excinfo.msg, 'spam')
+
+    def test_submit_exception_in_func(self):
+        fut = self.executor.submit(fail, Exception, 'spam')
+        with self.assertRaises(Exception) as captured:
+            fut.result()
+        self.assertIs(type(captured.exception), Exception)
+        self.assertEqual(str(captured.exception), 'spam')
+        cause = captured.exception.__cause__
+        self.assertIs(type(cause), ExecutionFailed)
+        for attr in ('__name__', '__qualname__', '__module__'):
+            self.assertEqual(getattr(cause.excinfo.type, attr),
+                             getattr(Exception, attr))
+        self.assertEqual(cause.excinfo.msg, 'spam')

    def test_saturation(self):
        blocker = queues.create()
        executor = self.executor_type(4, shared=dict(blocker=blocker))

        for i in range(15 * executor._max_workers):
-            executor.submit('blocker.get()')
+            executor.submit(exec, 'import __main__; __main__.blocker.get()')
+            #executor.submit('blocker.get()')
        self.assertEqual(len(executor._threads), executor._max_workers)
        for i in range(15 * executor._max_workers):
            blocker.put_nowait(None)