Avoid using event_loop.is_running() (#507)

Author: graingert

asgiref/sync.py

@@ -179,15 +179,14 @@ def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R:
 
         # You can't call AsyncToSync from a thread with a running event loop
         try:
-            event_loop = asyncio.get_running_loop()
+            asyncio.get_running_loop()
         except RuntimeError:
             pass
         else:
-            if event_loop.is_running():
-                raise RuntimeError(
-                    "You cannot use AsyncToSync in the same thread as an async event loop - "
-                    "just await the async function directly."
-                )
+            raise RuntimeError(
+                "You cannot use AsyncToSync in the same thread as an async event loop - "
+                "just await the async function directly."
+            )
 
         # Make a future for the return information
         call_result: "Future[_R]" = Future()
@@ -232,21 +231,28 @@ async def new_loop_wrap() -> None:
                 finally:
                     del self.loop_thread_executors[loop]
 
-            if not (self.main_event_loop and self.main_event_loop.is_running()):
+            if self.main_event_loop is not None:
+                try:
+                    self.main_event_loop.call_soon_threadsafe(
+                        self.main_event_loop.create_task, awaitable
+                    )
+                except RuntimeError:
+                    running_in_main_event_loop = False
+                else:
+                    running_in_main_event_loop = True
+                    # Run the CurrentThreadExecutor until the future is done.
+                    current_executor.run_until_future(call_result)
+            else:
+                running_in_main_event_loop = False
+
+            if not running_in_main_event_loop:
                 # Make our own event loop - in a new thread - and run inside that.
                 loop_executor = ThreadPoolExecutor(max_workers=1)
                 loop_future = loop_executor.submit(asyncio.run, new_loop_wrap())
                 # Run the CurrentThreadExecutor until the future is done.
                 current_executor.run_until_future(loop_future)
                 # Wait for future and/or allow for exception propagation
                 loop_future.result()
-            else:
-                # Call it inside the existing loop
-                self.main_event_loop.call_soon_threadsafe(
-                    self.main_event_loop.create_task, awaitable
-                )
-                # Run the CurrentThreadExecutor until the future is done.
-                current_executor.run_until_future(call_result)
         finally:
             _restore_context(context[0])
             # Restore old current thread executor state