Work on

python · asvetlov · Mar 24, 2022 · Mar 9, 2022 · Mar 10, 2022 · Mar 10, 2022
commit a443b3799bcb820ad2018655f69ecc8ac4525a3d
@@ -9,31 +9,39 @@ Runner
 
 ------------------------------------
 
-*Runner* context manager is used for two purposes:
 
-1. Providing a primitive for event loop initialization and finalization with correct
-   resources cleanup (cancelling background tasks, shutdowning the default thread-pool
-   executor and pending async generators, etc.)
+:func:`asyncio.run` provides a convinient very high-level API for running asyncio code.
 
-2. Processing *context variables* between async function calls.
+It is the preferred approach that satisfies almost all use cases.
 
-:func:`asyncio.run` is used for running asyncio code usually, but sometimes several
-top-level async calls are needed in the same loop and context instead of the
-single ``main()`` call provided by :func:`asyncio.run`.
+Sometimes several top-level async calls are needed in the same loop and contextvars
+context instead of the single ``main()`` call provided by :func:`asyncio.run`.
 
-For example, there is a synchronous unittest library or console framework that should
-work with async code.
-
-A code that The following examples are equal:
+The *Runner* context manager can be used for such things:
 
 .. code:: python
 
-   async def main():
-       ...
+   with asyncio.Runner() as runner:
+       runner.run(func1())
+       runner.run(func2())
+
+On the :class:`~asyncio.Runner` instantiation the new event loop is created.
+
+All :meth:`~asyncio.Runner.run` calls share the same :class:`~contextvars.Context` and
+internal :class:`~asyncio.l
10000
oop`.
+
+On the exit of :keyword:`with` block all background tasks are cancelled, the embedded
+loop is closing.
+
+
+.. class:: Runner(*, debug=None, factory=None)
+
+
+
 
-   asyncio.run(main())
 
 
+enter
 Usually,
 
 .. rubric:: Preface

@@ -1,5 +1,6 @@
 __all__ = ('Runner', 'run')
 
+import contextvars
 from . import coroutines
 from . import events
 from . import tasks
@@ -30,10 +31,14 @@ class Runner:
     asyncio.run() call doesn't work.
 
     """
-    def __init__(self, *, debug=None, factory=events.new_event_loop):
-        self._loop = factory()
+    def __init__(self, *, debug=None, factory=None):
+        if factory is None:
+            self._loop = events.new_event_loop()
+        else:
+            self._loop = factory()
         if debug is not None:
             self._loop.set_debug(debug)
+        self._context = contextvars.copy_context()
 
     def __enter__(self):
         return self
@@ -59,13 +64,21 @@ def run(self, coro, *, context=None):
         if not coroutines.iscoroutine(coro):
             raise ValueError("a coroutine was expected, got {!r}".format(coro))
 
+        if self._loop is None:
+            raise RuntimeError("Runner is closed")
+
+        if context is None:
+            context = self._context
         task = self._loop.create_task(coro, context=context)
         return self._loop.run_until_complete(task)
 
     def get_loop(self):
         """Returnb embedded event loop."""
         return self._loop
 
+    def get_context(self):
+        return self._context.copy()
+
 
 def run(main, *, debug=None):
     """Execute the coroutine and return the result.