new_contents: """Event loop implementation that uses the `asyncio` standard module.
  
  The `asyncio` module was added to python standard library on 3.4, and it
  provides a pure python implementation of an event loop library. It is used
  as a fallback in case pyuv is not available(on python implementations other
  than CPython).
  
  Earlier python versions are supported through the `trollius` package, which
  is a backport of `asyncio` that works on Python 2.6+.
  """
  from __future__ import absolute_import
  
  import os
  import sys
  from collections import deque
  
  try:
      # For python 3.4+, use the standard library module
      import asyncio
  except ImportError:
      # Fallback to trollius
      import trollius as asyncio
  
  from .base import BaseEventLoop
  
  
  loop_cls = asyncio.SelectorEventLoop
  if os.name == 'nt':
      # On windows use ProactorEventLoop which support pipes and is backed by the
      # more powerful IOCP facility
      loop_cls = asyncio.ProactorEventLoop
  
  
  class AsyncioEventLoop(BaseEventLoop, asyncio.Protocol,
                         asyncio.SubprocessProtocol):
  
      """`BaseEventLoop` subclass that uses `asyncio` as a backend."""
  
      def connection_made(self, transport):
          """Used to signal `asyncio.Protocol` of a successful connection."""
          self._transport = transport
          if isinstance(transport, asyncio.SubprocessTransport):
              self._transport = transport.get_pipe_transport(0)
  
      def connection_lost(self, exc):
          """Used to signal `asyncio.Protocol` of a lost connection."""
          self._on_error(exc.message)
  
      def data_received(self, data):
          """Used to signal `asyncio.Protocol` of incoming data."""
          if self._on_data:
              self._on_data(data)
              return
          self._queued_data.append(data)
  
      def pipe_connection_lost(self, exc):
          """Used to signal `asyncio.SubprocessProtocol` of a lost connection."""
          self._on_error(exc.message)
  
      def pipe_data_received(self, fd, data):
          """Used to signal `asyncio.SubprocessProtocol` of incoming data."""
          if fd == sys.stderr.fileno():
              self._on_stderr(data)
          elif self._on_data:
              self._on_data(data)
          else:
              self._queued_data.append(data)
  
      def process_exited(self):
          """Used to signal `asyncio.SubprocessProtocol` when the child exits."""
          self._on_error('EOF')
  
      def _init(self):
          self._loop = loop_cls()
          self._queued_data = deque()
          self._fact = lambda: self
  
      def _connect_tcp(self, address, port):
          coroutine = self._loop.create_connection(self._fact, address, port)
          self._loop.run_until_complete(coroutine)
  
      def _connect_socket(self, path):
          coroutine = self._loop.create_unix_connection(self._fact, path)
          self._loop.run_until_complete(coroutine)
  
      def _connect_stdio(self):
          coroutine = self._loop.connect_read_pipe(self._fact, sys.stdin)
          self._loop.run_until_complete(coroutine)
          coroutine = self._loop.connect_write_pipe(self._fact, sys.stdout)
          self._loop.run_until_complete(coroutine)
  
      def _connect_spawn(self, argv):
          coroutine = self._loop.subprocess_exec(self._fact, *argv)
          self._loop.run_until_complete(coroutine)
  
      def _start_reading(self):
          pass
  
      def _send(self, data):
          self._transport.write(data)
  
      def _run(self):
          while self._queued_data:
              self._on_data(self._queued_data.popleft())
          self._loop.run_forever()
  
      def _stop(self):
          self._loop.stop()
  
      def _interrupt(self):
          self._loop.call_soon_threadsafe(asyncio.async,
                                          lambda: self._loop.stop())
  
      def _setup_signals(self, signals):
          self._signals = list(signals)
          for signum in self._signals:
              self._loop.add_signal_handler(signum, self._on_signal, signum)
  
      def _teardown_signals(self):
          for signum in self._signals:
              self._loop.remove_signal_handler(signum)
  
subject: Implement event loop layer using asyncio