code: def run_in_background(coroutine: "Callable[[concurrent.futures.Future[T], Coroutine[Any, Any, None]]", *, debug: bool = False, _policy_lock: threading.Lock = threading.Lock()) -> T:
      
      assert asyncio.iscoroutinefunction(coroutine)
  
      with _policy_lock:
          if not isinstance(asyncio.get_event_loop_policy(), EventLoopPolicy):
              asyncio.set_event_loop_policy(EventLoopPolicy())
  
      future = concurrent.futures.Future()  # type: concurrent.futures.Future[T]
  
      def background() -> None:
          loop = asyncio.new_event_loop()
          asyncio.set_event_loop(loop)
          loop.set_debug(debug)
  
          try:
              loop.run_until_complete(coroutine(future))
              future.cancel()
          except Exception as exc:
              future.set_exception(exc)
              return
          finally:
              try:
                  # Finish all remaining tasks.
                  pending = _all_tasks(loop)
                  loop.run_until_complete(asyncio.gather(*pending, loop=loop, return_exceptions=True))
  
                  # Shutdown async generators.
                  try:
                      loop.run_until_complete(loop.shutdown_asyncgens())
                  except AttributeError:
                      # Before Python 3.6.
                      pass
              finally:
                  loop.close()
  
      threading.Thread(target=background).start()
      return future.result()
docs: Runs ``coroutine(future)`` in a new event loop on a background thread.
  
      Blocks and returns the *future* result as soon as it is resolved.
      The coroutine and all remaining tasks continue running in the background
      until it is complete.
  
      Note: This installs a :class:`chess.engine.EventLoopPolicy` for the entire
      process.