code: def run(
      main: Union[Coroutine[Any, None, _T], Awaitable[_T]],
      *,
      debug: bool = False,
  ) -> _T:
      """Run a coroutine.
  
      This function runs the passed coroutine, taking care of
      managing the asyncio event loop and finalizing asynchronous
      generators.
  
      This function cannot be called when another asyncio event loop is
      running in the same thread.
  
      If debug is True, the event loop will be run in debug mode.
  
      This function always creates a new event loop and closes it at the end.
      It should be used as a main entry point for asyncio programs, and should
      ideally only be called once.
  
      Example:
  
          async def main():
              await asyncio.sleep(1)
              print('hello')
  
          asyncio.run(main())
      """
      # Python 3.7+ raises RuntimeError while <3.6 returns None
      try:
          loop = get_running_loop()
      except RuntimeError:
          loop = None
      if loop is not None:
          raise RuntimeError(
              "asyncio.run() cannot be called from a running event loop"
          )
  
      if not asyncio.iscoroutine(main):
          raise ValueError(
              "a coroutine was expected, got {!r}".format(main)
          )
  
      loop = asyncio.new_event_loop()
      tasks = _patch_loop(loop)
  
      try:
          asyncio.set_event_loop(loop)
          loop.set_debug(debug)
          return loop.run_until_complete(main)
      finally:
          try:
              _cancel_all_tasks(loop, tasks)
              loop.run_until_complete(loop.shutdown_asyncgens())
          finally:
              asyncio.set_event_loop(None)  # type: ignore
              loop.close()
  
imports: import asyncio
  import weakref
  from typing import Any, Awaitable, Coroutine, TypeVar, Union
label_desc: Use image node_id 2 for calling a global function with example usage: run(main) and returns: loop