text: """
  Cooperative ``subprocess`` module.
  
  .. caution:: On POSIX platforms, this module is not usable from native
     threads other than the main thread; attempting to do so will raise
     a :exc:`TypeError`. This module depends on libev's fork watchers.
     On POSIX systems, fork watchers are implemented using signals, and
     the thread to which process-directed signals are delivered `is not
     defined`_. Because each native thread has its own gevent/libev
     loop, this means that a fork watcher registered with one loop
     (thread) may never see the signal about a child it spawned if the
     signal is sent to a different thread.
  
  .. note:: The interface of this module is intended to match that of
     the standard library :mod:`subprocess` module (with many backwards
     compatible extensions from Python 3 backported to Python 2). There
     are some small differences between the Python 2 and Python 3
     versions of that module (the Python 2 ``TimeoutExpired`` exception,
     notably, extends ``Timeout`` and there is no ``SubprocessError``) and between the
     POSIX and Windows versions. The HTML documentation here can only
     describe one version; for definitive documentation, see the
     standard library or the source code.
  
  .. _is not defined: http://www.linuxprogrammingblog.com/all-about-linux-signals?page=11
  """
  from __future__ import absolute_import, print_function
  # Can we split this up to make it cleaner? See https://github.com/gevent/gevent/issues/748
  # pylint: disable=too-many-lines
  # Import magic
  # pylint: disable=undefined-all-variable,undefined-variable
  # Most of this we inherit from the standard lib
  # pylint: disable=bare-except,too-many-locals,too-many-statements,attribute-defined-outside-init
  # pylint: disable=too-many-branches,too-many-instance-attributes
  # Most of this is cross-platform
  # pylint: disable=no-member,expression-not-assigned,unused-argument,unused-variable
  import errno
  import gc
  import os
  import signal
  import sys
  import traceback
  from gevent.event import AsyncResult
  from gevent.hub import get_hub, linkproxy, sleep, getcurrent
  from gevent._compat import integer_types, string_types, xrange
  from gevent._compat import PY3
  from gevent._compat import reraise
  from gevent._util import _NONE
  from gevent._util import copy_globals
  from gevent.fileobject import FileObject
  from gevent.greenlet import Greenlet, joinall
  spawn = Greenlet.spawn
  import subprocess as __subprocess__
  
  
  # Standard functions and classes that this module re-implements in a gevent-aware way.
  __implements__ = [
      'Popen',
      'call',
      'check_call',
      'check_output',
  ]
  if PY3 and not sys.platform.startswith('win32'):
      __implements__.append("_posixsubprocess")
      _posixsubprocess = None
  
  # Some symbols we define that we expect to export;
  # useful for static analysis
  PIPE = "PIPE should be imported"
  
  # Standard functions and classes that this module re-imports.
  __imports__ = [
      'PIPE',
      'STDOUT',
      'CalledProcessError',
      # Windows:
      'CREATE_NEW_CONSOLE',
      'CREATE_NEW_PROCESS_GROUP',
      'STD_INPUT_HANDLE',
      'STD_OUTPUT_HANDLE',
      'STD_ERROR_HANDLE',
      'SW_HIDE',
      'STARTF_USESTDHANDLES',
      'STARTF_USESHOWWINDOW',
  ]
  
  
  __extra__ = [
      'MAXFD',
      '_eintr_retry_call',
      'STARTUPINFO',
      'pywintypes',
      'list2cmdline',
      '_subprocess',
      '_winapi',
      # Python 2.5 does not have _subprocess, so we don't use it
      # XXX We don't run on Py 2.5 anymore; can/could/should we use _subprocess?
      # It's only used on mswindows
      'WAIT_OBJECT_0',
      'WaitForSingleObject',
      'GetExitCodeProcess',
      'GetStdHandle',
      'CreatePipe',
      'DuplicateHandle',
      'GetCurrentProcess',
      'DUPLICATE_SAME_ACCESS',
      'GetModuleFileName',
      'GetVersion',
      'CreateProcess',
      'INFINITE',
      'TerminateProcess',
  
      # These were added for 3.5, but we make them available everywhere.
      'run',
      'CompletedProcess',
  ]
  
  if sys.version_info[:2] >= (3, 3):
      __imports__ += [
          'DEVNULL',
          'getstatusoutput',
          'getoutput',
          'SubprocessError',
          'TimeoutExpired',
      ]
  else:
      __extra__.append("TimeoutExpired")
  
  
  if sys.version_info[:2] >= (3, 5):
      __extra__.remove('run')
      __extra__.remove('CompletedProcess')
      __implements__.append('run')
      __implements__.append('CompletedProcess')
  
      # Removed in Python 3.5; this is the exact code that was removed:
      # https://hg.python.org/cpython/rev/f98b0a5e5ef5
      __extra__.remove('MAXFD')
      try:
          MAXFD = os.sysconf("SC_OPEN_MAX")
      except:
          MAXFD = 256
  
  if sys.version_info[:2] >= (3, 6):
      # This was added to __all__ for windows in 3.6
      __extra__.remove('STARTUPINFO')
      __imports__.append('STARTUPINFO')
  
  actually_imported = copy_globals(__subprocess__, globals(),
                                   only_names=__imports__,
                                   ignore_missing_names=True)
  # anything we couldn't import from here we may need to find
  # elsewhere
  __extra__.extend(set(__imports__).difference(set(actually_imported)))
  __imports__ = actually_imported
  del actually_imported
  
  
  # In Python 3 on Windows, a lot of the functions previously
  # in _subprocess moved to _winapi
  _subprocess = getattr(__subprocess__, '_subprocess', _NONE)
  _winapi = getattr(__subprocess__, '_winapi', _NONE)
  
  _attr_resolution_order = [__subprocess__, _subprocess, _winapi]
  
  for name in list(__extra__):
      if name in globals():
          continue
      value = _NONE
      for place in _attr_resolution_order:
          value = getattr(place, name, _NONE)
          if value is not _NONE:
              break
  
      if value is _NONE:
          __extra__.remove(name)
      else:
          globals()[name] = value
  
  del _attr_resolution_order
  __all__ = __implements__ + __imports__
  # Some other things we want to document
  for _x in ('run', 'CompletedProcess', 'TimeoutExpired'):
      if _x not in __all__:
          __all__.append(_x)
  
  
  mswindows = sys.platform == 'win32'
  if mswindows:
      import msvcrt # pylint: disable=import-error
      if PY3:
          class Handle(int):
              closed = False
  
              def Close(self):
                  if not self.closed:
                      self.closed = True
                      _winapi.CloseHandle(self)
  
              def Detach(self):
                  if not self.closed:
                      self.closed = True
                      return int(self)
                  raise ValueError("already closed")
  
              def __repr__(self):
                  return "Handle(%d)" % int(self)
  
              __del__ = Close
              __str__ = __repr__
  else:
      import fcntl
      import pickle
      from gevent import monkey
      fork = monkey.get_original('os', 'fork')
      from gevent.os import fork_and_watch
  
  def call(*popenargs, **kwargs):
      """
      call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None) -> returncode
  
      Run command with arguments. Wait for command to complete or
      timeout, then return the returncode attribute.
  
      The arguments are the same as for the Popen constructor.  Example::
  
          retcode = call(["ls", "-l"])
  
      .. versionchanged:: 1.2a1
         The ``timeout`` keyword argument is now accepted on all supported
         versions of Python (not just Python 3) and if it expires will raise a
         :exc:`TimeoutExpired` exception (under Python 2 this is a subclass of :exc:`~.Timeout`).
      """
      timeout = kwargs.pop('timeout', None)
      with Popen(*popenargs, **kwargs) as p:
          try:
              return p.wait(timeout=timeout, _raise_exc=True)
          except:
              p.kill()
              p.wait()
              raise
  
  def check_call(*popenargs, **kwargs):
      """
      check_call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None) -> 0
  
      Run command with arguments.  Wait for command to complete.  If
      the exit code was zero then return, otherwise raise
      :exc:`CalledProcessError`.  The ``CalledProcessError`` object will have the
      return code in the returncode attribute.
  
      The arguments are the same as for the Popen constructor.  Example::
  
          retcode = check_call(["ls", "-l"])
      """
      retcode = call(*popenargs, **kwargs)
      if retcode:
          cmd = kwargs.get("args")
          if cmd is None:
              cmd = popenargs[0]
          raise CalledProcessError(retcode, cmd)
      return 0
  
  def check_output(*popenargs, **kwargs):
      r"""
      check_output(args, *, input=None, stdin=None, stderr=None, shell=False, universal_newlines=False, timeout=None) -> output
  
      Run command with arguments and return its output.
  
      If the exit code was non-zero it raises a :exc:`CalledProcessError`.  The
      ``CalledProcessError`` object will have the return code in the returncode
      attribute and output in the output attribute.
  
  
      The arguments are the same as for the Popen constructor.  Example::
  
          >>> check_output(["ls", "-1", "/dev/null"])
          '/dev/null\n'
  
      The ``stdout`` argument is not allowed as it is used internally.
  
      To capture standard error in the result, use ``stderr=STDOUT``::
  
          >>> check_output(["/bin/sh", "-c",
          ...               "ls -l non_existent_file ; exit 0"],
          ...              stderr=STDOUT)
          'ls: non_existent_file: No such file or directory\n'
  
      There is an additional optional argument, "input", allowing you to
      pass a string to the subprocess's stdin.  If you use this argument
      you may not also use the Popen constructor's "stdin" argument, as
      it too will be used internally.  Example::
  
          >>> check_output(["sed", "-e", "s/foo/bar/"],
          ...              input=b"when in the course of fooman events\n")
          'when in the course of barman events\n'
  
      If ``universal_newlines=True`` is passed, the return value will be a
      string rather than bytes.
  
      .. versionchanged:: 1.2a1
         The ``timeout`` keyword argument is now accepted on all supported
         versions of Python (not just Python 3) and if it expires will raise a
         :exc:`TimeoutExpired` exception (under Python 2 this is a subclass of :exc:`~.Timeout`).
      .. versionchanged:: 1.2a1
         The ``input`` keyword argument is now accepted on all supported
         versions of Python, not just Python 3
      """
      timeout = kwargs.pop('timeout', None)
      if 'stdout' in kwargs:
          raise ValueError('stdout argument not allowed, it will be overridden.')
      if 'input' in kwargs:
          if 'stdin' in kwargs:
              raise ValueError('stdin and input arguments may not both be used.')
          inputdata = kwargs['input']
          del kwargs['input']
          kwargs['stdin'] = PIPE
      else:
          inputdata = None
      with Popen(*popenargs, stdout=PIPE, **kwargs) as process:
          try:
              output, unused_err = process.communicate(inputdata, timeout=timeout)
          except TimeoutExpired:
              process.kill()
              output, unused_err = process.communicate()
              raise TimeoutExpired(process.args, timeout, output=output)
          except:
              process.kill()
              process.wait()
              raise
          retcode = process.poll()
          if retcode:
              raise CalledProcessError(retcode, process.args, output=output)
      return output
  
  _PLATFORM_DEFAULT_CLOSE_FDS = object()
  
  if 'TimeoutExpired' not in globals():
      # Python 2
  
      # Make TimeoutExpired inherit from _Timeout so it can be caught
      # the way we used to throw things (except Timeout), but make sure it doesn't
      # init a timer. Note that we can't have a fake 'SubprocessError' that inherits
      # from exception, because we need TimeoutExpired to just be a BaseException for
      # bwc.
      from gevent.timeout import Timeout as _Timeout
  
      class TimeoutExpired(_Timeout):
          """
          This exception is raised when the timeout expires while waiting for
          a child process in `communicate`.
  
          Under Python 2, this is a gevent extension with the same name as the
          Python 3 class for source-code forward compatibility. However, it extends
          :class:`gevent.timeout.Timeout` for backwards compatibility (because
          we used to just raise a plain ``Timeout``); note that ``Timeout`` is a
          ``BaseException``, *not* an ``Exception``.
  
          .. versionadded:: 1.2a1
          """
          def __init__(self, cmd, timeout, output=None):
              _Timeout.__init__(self, timeout, _use_timer=False)
              self.cmd = cmd
              self.timeout = timeout
              self.output = output
  
          def __str__(self):
              return ("Command '%s' timed out after %s seconds" %
                      (self.cmd, self.timeout))
  
  
  class Popen(object):
      """
      The underlying process creation and management in this module is
      handled by the Popen class. It offers a lot of flexibility so that
      developers are able to handle the less common cases not covered by
      the convenience functions.
  
      .. seealso:: :class:`subprocess.Popen`
         This class should have the same interface as the standard library class.
  
      .. versionchanged:: 1.2a1
         Instances can now be used as context managers under Python 2.7. Previously
         this was restricted to Python 3.
  
      .. versionchanged:: 1.2a1
         Instances now save the ``args`` attribute under Python 2.7. Previously this was
         restricted to Python 3.
      """
  
      def __init__(self, args, bufsize=None, executable=None,
                   stdin=None, stdout=None, stderr=None,
                   preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS, shell=False,
                   cwd=None, env=None, universal_newlines=False,
                   startupinfo=None, creationflags=0, threadpool=None,
                   **kwargs):
          """Create new Popen instance.
  
          :param kwargs: *Only* allowed under Python 3; under Python 2, any
            unrecognized keyword arguments will result in a :exc:`TypeError`.
            Under Python 3, keyword arguments can include ``pass_fds``, ``start_new_session``,
            ``restore_signals``, ``encoding`` and ``errors``
  
          .. versionchanged:: 1.2b1
             Add the ``encoding`` and ``errors`` parameters for Python 3.
          """
  
          if not PY3 and kwargs:
              raise TypeError("Got unexpected keyword arguments", kwargs)
          pass_fds = kwargs.pop('pass_fds', ())
          start_new_session = kwargs.pop('start_new_session', False)
          restore_signals = kwargs.pop('restore_signals', True)
          # Added in 3.6. These are kept as ivars
          encoding = self.encoding = kwargs.pop('encoding', None)
          errors = self.errors = kwargs.pop('errors', None)
  
          hub = get_hub()
  
          if bufsize is None:
              # bufsize has different defaults on Py3 and Py2
              if PY3:
                  bufsize = -1
              else:
                  bufsize = 0
          if not isinstance(bufsize, integer_types):
              raise TypeError("bufsize must be an integer")
  
          if mswindows:
              if preexec_fn is not None:
                  raise ValueError("preexec_fn is not supported on Windows "
                                   "platforms")
              any_stdio_set = (stdin is not None or stdout is not None or
                               stderr is not None)
              if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS:
                  if any_stdio_set:
                      close_fds = False
                  else:
                      close_fds = True
              elif close_fds and any_stdio_set:
                  raise ValueError("close_fds is not supported on Windows "
                                   "platforms if you redirect stdin/stdout/stderr")
              if threadpool is None:
                  threadpool = hub.threadpool
              self.threadpool = threadpool
              self._waiting = False
          else:
              # POSIX
              if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS:
                  # close_fds has different defaults on Py3/Py2
                  if PY3: # pylint: disable=simplifiable-if-statement
                      close_fds = True
                  else:
                      close_fds = False
  
              if pass_fds and not close_fds:
                  import warnings
                  warnings.warn("pass_fds overriding close_fds.", RuntimeWarning)
                  close_fds = True
              if startupinfo is not None:
                  raise ValueError("startupinfo is only supported on Windows "
                                   "platforms")
              if creationflags != 0:
                  raise ValueError("creationflags is only supported on Windows "
                                   "platforms")
              assert threadpool is None
              self._loop = hub.loop
  
          self.args = args # Previously this was Py3 only.
          self.stdin = None
          self.stdout = None
          self.stderr = None
          self.pid = None
          self.returncode = None
          self.universal_newlines = universal_newlines
          self.result = AsyncResult()
  
          # Input and output objects. The general principle is like
          # this:
          #
          # Parent                   Child
          # ------                   -----
          # p2cwrite   ---stdin--->  p2cread
          # c2pread    <--stdout---  c2pwrite
          # errread    <--stderr---  errwrite
          #
          # On POSIX, the child objects are file descriptors.  On
          # Windows, these are Windows file handles.  The parent objects
          # are file descriptors on both platforms.  The parent objects
          # are None when not using PIPEs. The child objects are None
          # when not redirecting.
  
          (p2cread, p2cwrite,
           c2pread, c2pwrite,
           errread, errwrite) = self._get_handles(stdin, stdout, stderr)
  
          # We wrap OS handles *before* launching the child, otherwise a
          # quickly terminating child could make our fds unwrappable
          # (see #8458).
          if mswindows:
              if p2cwrite is not None:
                  p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
              if c2pread is not None:
                  c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
              if errread is not None:
                  errread = msvcrt.open_osfhandle(errread.Detach(), 0)
  
          text_mode = PY3 and (self.encoding or self.errors or universal_newlines)
  
          if p2cwrite is not None:
              if PY3 and text_mode:
                  # Under Python 3, if we left on the 'b' we'd get different results
                  # depending on whether we used FileObjectPosix or FileObjectThread
                  self.stdin = FileObject(p2cwrite, 'wb', bufsize)
                  self.stdin.translate_newlines(None,
                                                write_through=True,
                                                line_buffering=(bufsize == 1),
                                                encoding=self.encoding, errors=self.errors)
              else:
                  self.stdin = FileObject(p2cwrite, 'wb', bufsize)
          if c2pread is not None:
              if universal_newlines or text_mode:
                  if PY3:
                      # FileObjectThread doesn't support the 'U' qualifier
                      # with a bufsize of 0
                      self.stdout = FileObject(c2pread, 'rb', bufsize)
                      # NOTE: Universal Newlines are broken on Windows/Py3, at least
                      # in some cases. This is true in the stdlib subprocess module
                      # as well; the following line would fix the test cases in
                      # test__subprocess.py that depend on python_universal_newlines,
                      # but would be inconsistent with the stdlib:
                      #msvcrt.setmode(self.stdout.fileno(), os.O_TEXT)
                      self.stdout.translate_newlines('r', encoding=self.encoding, errors=self.errors)
                  else:
                      self.stdout = FileObject(c2pread, 'rU', bufsize)
              else:
                  self.stdout = FileObject(c2pread, 'rb', bufsize)
          if errread is not None:
              if universal_newlines or text_mode:
                  if PY3:
                      self.stderr = FileObject(errread, 'rb', bufsize)
                      self.stderr.translate_newlines(None, encoding=encoding, errors=errors)
                  else:
                      self.stderr = FileObject(errread, 'rU', bufsize)
              else:
                  self.stderr = FileObject(errread, 'rb', bufsize)
  
          self._closed_child_pipe_fds = False
          try:
              self._execute_child(args, executable, preexec_fn, close_fds,
                                  pass_fds, cwd, env, universal_newlines,
                                  startupinfo, creationflags, shell,
                                  p2cread, p2cwrite,
                                  c2pread, c2pwrite,
                                  errread, errwrite,
                                  restore_signals, start_new_session)
          except:
              # Cleanup if the child failed starting.
              # (gevent: New in python3, but reported as gevent bug in #347.
              # Note that under Py2, any error raised below will replace the
              # original error so we have to use reraise)
              if not PY3:
                  exc_info = sys.exc_info()
              for f in filter(None, (self.stdin, self.stdout, self.stderr)):
                  try:
                      f.close()
                  except (OSError, IOError):
                      pass  # Ignore EBADF or other errors.
  
              if not self._closed_child_pipe_fds:
                  to_close = []
                  if stdin == PIPE:
                      to_close.append(p2cread)
                  if stdout == PIPE:
                      to_close.append(c2pwrite)
                  if stderr == PIPE:
                      to_close.append(errwrite)
                  if hasattr(self, '_devnull'):
                      to_close.append(self._devnull)
                  for fd in to_close:
                      try:
                          os.close(fd)
                      except (OSError, IOError):
                          pass
              if not PY3:
                  try:
                      reraise(*exc_info)
                  finally:
                      del exc_info
              raise
  
      def __repr__(self):
          return '<%s at 0x%x pid=%r returncode=%r>' % (self.__class__.__name__, id(self), self.pid, self.returncode)
  
      def _on_child(self, watcher):
          watcher.stop()
          status = watcher.rstatus
          if os.WIFSIGNALED(status):
              self.returncode = -os.WTERMSIG(status)
          else:
              self.returncode = os.WEXITSTATUS(status)
          self.result.set(self.returncode)
  
      def _get_devnull(self):
          if not hasattr(self, '_devnull'):
              self._devnull = os.open(os.devnull, os.O_RDWR)
          return self._devnull
  
      _stdout_buffer = None
      _stderr_buffer = None
  
      def communicate(self, input=None, timeout=None):
          """Interact with process: Send data to stdin.  Read data from
          stdout and stderr, until end-of-file is reached.  Wait for
          process to terminate.  The optional input argument should be a
          string to be sent to the child process, or None, if no data
          should be sent to the child.
  
          communicate() returns a tuple (stdout, stderr).
  
          :keyword timeout: Under Python 2, this is a gevent extension; if
             given and it expires, we will raise :exc:`TimeoutExpired`, which
             extends :exc:`gevent.timeout.Timeout` (note that this only extends :exc:`BaseException`,
             *not* :exc:`Exception`)
             Under Python 3, this raises the standard :exc:`TimeoutExpired` exception.
  
          .. versionchanged:: 1.1a2
             Under Python 2, if the *timeout* elapses, raise the :exc:`gevent.timeout.Timeout`
             exception. Previously, we silently returned.
          .. versionchanged:: 1.1b5
             Honor a *timeout* even if there's no way to communicate with the child
             (stdin, stdout, and stderr are not pipes).
          """
          greenlets = []
          if self.stdin:
              greenlets.append(spawn(write_and_close, self.stdin, input))
  
          # If the timeout parameter is used, and the caller calls back after
          # getting a TimeoutExpired exception, we can wind up with multiple
          # greenlets trying to run and read from and close stdout/stderr.
          # That's bad because it can lead to 'RuntimeError: reentrant call in io.BufferedReader'.
          # We can't just kill the previous greenlets when a timeout happens,
          # though, because we risk losing the output collected by that greenlet
          # (and Python 3, where timeout is an official parameter, explicitly says
          # that no output should be lost in the event of a timeout.) Instead, we're
          # watching for the exception and ignoring it. It's not elegant,
          # but it works
          if self.stdout:
              def _read_out():
                  try:
                      data = self.stdout.read()
                  except RuntimeError:
                      return
                  if self._stdout_buffer is not None:
                      self._stdout_buffer += data
                  else:
                      self._stdout_buffer = data
              stdout = spawn(_read_out)
              greenlets.append(stdout)
          else:
              stdout = None
  
          if self.stderr:
              def _read_err():
                  try:
                      data = self.stderr.read()
                  except RuntimeError:
                      return
                  if self._stderr_buffer is not None:
                      self._stderr_buffer += data
                  else:
                      self._stderr_buffer = data
              stderr = spawn(_read_err)
              greenlets.append(stderr)
          else:
              stderr = None
  
          # If we were given stdin=stdout=stderr=None, we have no way to
          # communicate with the child, and thus no greenlets to wait
          # on. This is a nonsense case, but it comes up in the test
          # case for Python 3.5 (test_subprocess.py
          # RunFuncTestCase.test_timeout). Instead, we go directly to
          # self.wait
          if not greenlets and timeout is not None:
              self.wait(timeout=timeout, _raise_exc=True)
  
          done = joinall(greenlets, timeout=timeout)
          if timeout is not None and len(done) != len(greenlets):
              raise TimeoutExpired(self.args, timeout)
  
          if self.stdout:
              try:
                  self.stdout.close()
              except RuntimeError:
                  pass
          if self.stderr:
              try:
                  self.stderr.close()
              except RuntimeError:
                  pass
          self.wait()
          stdout_value = self._stdout_buffer
          self._stdout_buffer = None
          stderr_value = self._stderr_buffer
          self._stderr_buffer = None
          # XXX: Under python 3 in universal newlines mode we should be
          # returning str, not bytes
          return (None if stdout is None else stdout_value or b'',
                  None if stderr is None else stderr_value or b'')
  
      def poll(self):
          """Check if child process has terminated. Set and return :attr:`returncode` attribute."""
          return self._internal_poll()
  
      def __enter__(self):
          return self
  
      def __exit__(self, t, v, tb):
          if self.stdout:
              self.stdout.close()
          if self.stderr:
              self.stderr.close()
          try:  # Flushing a BufferedWriter may raise an error
              if self.stdin:
                  self.stdin.close()
          finally:
              # Wait for the process to terminate, to avoid zombies.
              # JAM: gevent: If the process never terminates, this
              # blocks forever.
              self.wait()
  
      def _gevent_result_wait(self, timeout=None, raise_exc=PY3):
          result = self.result.wait(timeout=timeout)
          if raise_exc and timeout is not None and not self.result.ready():
              raise TimeoutExpired(self.args, timeout)
          return result
  
  
      if mswindows:
          #
          # Windows methods
          #
          def _get_handles(self, stdin, stdout, stderr):
              """Construct and return tuple with IO objects:
              p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
              """
              if stdin is None and stdout is None and stderr is None:
                  return (None, None, None, None, None, None)
  
              p2cread, p2cwrite = None, None
              c2pread, c2pwrite = None, None
              errread, errwrite = None, None
  
              try:
                  DEVNULL
              except NameError:
                  _devnull = object()
              else:
                  _devnull = DEVNULL
  
              if stdin is None:
                  p2cread = GetStdHandle(STD_INPUT_HANDLE)
                  if p2cread is None:
                      p2cread, _ = CreatePipe(None, 0)
                      if PY3:
                          p2cread = Handle(p2cread)
                          _winapi.CloseHandle(_)
              elif stdin == PIPE:
                  p2cread, p2cwrite = CreatePipe(None, 0)
                  if PY3:
                      p2cread, p2cwrite = Handle(p2cread), Handle(p2cwrite)
              elif stdin == _devnull:
                  p2cread = msvcrt.get_osfhandle(self._get_devnull())
              elif isinstance(stdin, int):
                  p2cread = msvcrt.get_osfhandle(stdin)
              else:
                  # Assuming file-like object
                  p2cread = msvcrt.get_osfhandle(stdin.fileno())
              p2cread = self._make_inheritable(p2cread)
  
              if stdout is None:
                  c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE)
                  if c2pwrite is None:
                      _, c2pwrite = CreatePipe(None, 0)
                      if PY3:
                          c2pwrite = Handle(c2pwrite)
                          _winapi.CloseHandle(_)
              elif stdout == PIPE:
                  c2pread, c2pwrite = CreatePipe(None, 0)
                  if PY3:
                      c2pread, c2pwrite = Handle(c2pread), Handle(c2pwrite)
              elif stdout == _devnull:
                  c2pwrite = msvcrt.get_osfhandle(self._get_devnull())
              elif isinstance(stdout, int):
                  c2pwrite = msvcrt.get_osfhandle(stdout)
              else:
                  # Assuming file-like object
                  c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
              c2pwrite = self._make_inheritable(c2pwrite)
  
              if stderr is None:
                  errwrite = GetStdHandle(STD_ERROR_HANDLE)
                  if errwrite is None:
                      _, errwrite = CreatePipe(None, 0)
                      if PY3:
                          errwrite = Handle(errwrite)
                          _winapi.CloseHandle(_)
              elif stderr == PIPE:
                  errread, errwrite = CreatePipe(None, 0)
                  if PY3:
                      errread, errwrite = Handle(errread), Handle(errwrite)
              elif stderr == STDOUT:
                  errwrite = c2pwrite
              elif stderr == _devnull:
                  errwrite = msvcrt.get_osfhandle(self._get_devnull())
              elif isinstance(stderr, int):
                  errwrite = msvcrt.get_osfhandle(stderr)
              else:
                  # Assuming file-like object
                  errwrite = msvcrt.get_osfhandle(stderr.fileno())
              errwrite = self._make_inheritable(errwrite)
  
              return (p2cread, p2cwrite,
                      c2pread, c2pwrite,
                      errread, errwrite)
  
          def _make_inheritable(self, handle):
              """Return a duplicate of handle, which is inheritable"""
              return DuplicateHandle(GetCurrentProcess(),
                                     handle, GetCurrentProcess(), 0, 1,
                                     DUPLICATE_SAME_ACCESS)
  
          def _find_w9xpopen(self):
              """Find and return absolute path to w9xpopen.exe"""
              w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)),
                                      "w9xpopen.exe")
              if not os.path.exists(w9xpopen):
                  # Eeek - file-not-found - possibly an embedding
                  # situation - see if we can locate it in sys.exec_prefix
                  w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix),
                                          "w9xpopen.exe")
                  if not os.path.exists(w9xpopen):
                      raise RuntimeError("Cannot locate w9xpopen.exe, which is "
                                         "needed for Popen to work with your "
                                         "shell or platform.")
              return w9xpopen
  
          def _execute_child(self, args, executable, preexec_fn, close_fds,
                             pass_fds, cwd, env, universal_newlines,
                             startupinfo, creationflags, shell,
                             p2cread, p2cwrite,
                             c2pread, c2pwrite,
                             errread, errwrite,
                             unused_restore_signals, unused_start_new_session):
              """Execute program (MS Windows version)"""
  
              assert not pass_fds, "pass_fds not supported on Windows."
  
              if not isinstance(args, string_types):
                  args = list2cmdline(args)
  
              # Process startup details
              if startupinfo is None:
                  startupinfo = STARTUPINFO()
              if None not in (p2cread, c2pwrite, errwrite):
                  startupinfo.dwFlags |= STARTF_USESTDHANDLES
                  startupinfo.hStdInput = p2cread
                  startupinfo.hStdOutput = c2pwrite
                  startupinfo.hStdError = errwrite
  
              if shell:
                  startupinfo.dwFlags |= STARTF_USESHOWWINDOW
                  startupinfo.wShowWindow = SW_HIDE
                  comspec = os.environ.get("COMSPEC", "cmd.exe")
                  args = '{} /c "{}"'.format(comspec, args)
                  if GetVersion() >= 0x80000000 or os.path.basename(comspec).lower() == "command.com":
                      # Win9x, or using command.com on NT. We need to
                      # use the w9xpopen intermediate program. For more
                      # information, see KB Q150956
                      # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp)
                      w9xpopen = self._find_w9xpopen()
                      args = '"%s" %s' % (w9xpopen, args)
                      # Not passing CREATE_NEW_CONSOLE has been known to
                      # cause random failures on win9x.  Specifically a
                      # dialog: "Your program accessed mem currently in
                      # use at xxx" and a hopeful warning about the
                      # stability of your system.  Cost is Ctrl+C wont
                      # kill children.
                      creationflags |= CREATE_NEW_CONSOLE
  
              # Start the process
              try:
                  hp, ht, pid, tid = CreateProcess(executable, args,
                                                   # no special security
                                                   None, None,
                                                   int(not close_fds),
                                                   creationflags,
                                                   env,
                                                   cwd,
                                                   startupinfo)
              except IOError as e: # From 2.6 on, pywintypes.error was defined as IOError
                  # Translate pywintypes.error to WindowsError, which is
                  # a subclass of OSError.  FIXME: We should really
                  # translate errno using _sys_errlist (or similar), but
                  # how can this be done from Python?
                  if PY3:
                      raise # don't remap here
                  raise WindowsError(*e.args)
              finally:
                  # Child is launched. Close the parent's copy of those pipe
                  # handles that only the child should have open.  You need
                  # to make sure that no handles to the write end of the
                  # output pipe are maintained in this process or else the
                  # pipe will not close when the child process exits and the
                  # ReadFile will hang.
                  def _close(x):
                      if x is not None and x != -1:
                          if hasattr(x, 'Close'):
                              x.Close()
                          else:
                              _winapi.CloseHandle(x)
  
                  _close(p2cread)
                  _close(c2pwrite)
                  _close(errwrite)
                  if hasattr(self, '_devnull'):
                      os.close(self._devnull)
  
              # Retain the process handle, but close the thread handle
              self._child_created = True
              self._handle = Handle(hp) if not hasattr(hp, 'Close') else hp
              self.pid = pid
              _winapi.CloseHandle(ht) if not hasattr(ht, 'Close') else ht.Close()
  
          def _internal_poll(self):
              """Check if child process has terminated.  Returns returncode
              attribute.
              """
              if self.returncode is None:
                  if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0:
                      self.returncode = GetExitCodeProcess(self._handle)
                      self.result.set(self.returncode)
              return self.returncode
  
          def rawlink(self, callback):
              if not self.result.ready() and not self._waiting:
                  self._waiting = True
                  Greenlet.spawn(self._wait)
              self.result.rawlink(linkproxy(callback, self))
              # XXX unlink
  
          def _blocking_wait(self):
              WaitForSingleObject(self._handle, INFINITE)
              self.returncode = GetExitCodeProcess(self._handle)
              return self.returncode
  
          def _wait(self):
              self.threadpool.spawn(self._blocking_wait).rawlink(self.result)
  
          def wait(self, timeout=None, _raise_exc=PY3):
              """Wait for child process to terminate.  Returns returncode
              attribute."""
              if self.returncode is None:
                  if not self._waiting:
                      self._waiting = True
                      self._wait()
              return self._gevent_result_wait(timeout, _raise_exc)
  
          def send_signal(self, sig):
              """Send a signal to the process
              """
              if sig == signal.SIGTERM:
                  self.terminate()
              elif sig == signal.CTRL_C_EVENT:
                  os.kill(self.pid, signal.CTRL_C_EVENT)
              elif sig == signal.CTRL_BREAK_EVENT:
                  os.kill(self.pid, signal.CTRL_BREAK_EVENT)
              else:
                  raise ValueError("Unsupported signal: {}".format(sig))
  
          def terminate(self):
              """Terminates the process
              """
              TerminateProcess(self._handle, 1)
  
          kill = terminate
  
      else:
          #
          # POSIX methods
          #
  
          def rawlink(self, callback):
              # Not public documented, part of the link protocol
              self.result.rawlink(linkproxy(callback, self))
          # XXX unlink
  
          def _get_handles(self, stdin, stdout, stderr):
              """Construct and return tuple with IO objects:
              p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
              """
              p2cread, p2cwrite = None, None
              c2pread, c2pwrite = None, None
              errread, errwrite = None, None
  
              try:
                  DEVNULL
              except NameError:
                  _devnull = object()
              else:
                  _devnull = DEVNULL
  
              if stdin is None:
                  pass
              elif stdin == PIPE:
                  p2cread, p2cwrite = self.pipe_cloexec()
              elif stdin == _devnull:
                  p2cread = self._get_devnull()
              elif isinstance(stdin, int):
                  p2cread = stdin
              else:
                  # Assuming file-like object
                  p2cread = stdin.fileno()
  
              if stdout is None:
                  pass
              elif stdout == PIPE:
                  c2pread, c2pwrite = self.pipe_cloexec()
              elif stdout == _devnull:
                  c2pwrite = self._get_devnull()
              elif isinstance(stdout, int):
                  c2pwrite = stdout
              else:
                  # Assuming file-like object
                  c2pwrite = stdout.fileno()
  
              if stderr is None:
                  pass
              elif stderr == PIPE:
                  errread, errwrite = self.pipe_cloexec()
              elif stderr == STDOUT:
                  errwrite = c2pwrite
              elif stderr == _devnull:
                  errwrite = self._get_devnull()
              elif isinstance(stderr, int):
                  errwrite = stderr
              else:
                  # Assuming file-like object
                  errwrite = stderr.fileno()
  
              return (p2cread, p2cwrite,
                      c2pread, c2pwrite,
                      errread, errwrite)
  
          def _set_cloexec_flag(self, fd, cloexec=True):
              try:
                  cloexec_flag = fcntl.FD_CLOEXEC
              except AttributeError:
                  cloexec_flag = 1
  
              old = fcntl.fcntl(fd, fcntl.F_GETFD)
              if cloexec:
                  fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag)
              else:
                  fcntl.fcntl(fd, fcntl.F_SETFD, old & ~cloexec_flag)
  
          def _remove_nonblock_flag(self, fd):
              flags = fcntl.fcntl(fd, fcntl.F_GETFL) & (~os.O_NONBLOCK)
              fcntl.fcntl(fd, fcntl.F_SETFL, flags)
  
          def pipe_cloexec(self):
              """Create a pipe with FDs set CLOEXEC."""
              # Pipes' FDs are set CLOEXEC by default because we don't want them
              # to be inherited by other subprocesses: the CLOEXEC flag is removed
              # from the child's FDs by _dup2(), between fork() and exec().
              # This is not atomic: we would need the pipe2() syscall for that.
              r, w = os.pipe()
              self._set_cloexec_flag(r)
              self._set_cloexec_flag(w)
              return r, w
  
          def _close_fds(self, keep):
              # `keep` is a set of fds, so we
              # use os.closerange from 3 to min(keep)
              # and then from max(keep + 1) to MAXFD and
              # loop through filling in the gaps.
              # Under new python versions, we need to explicitly set
              # passed fds to be inheritable or they will go away on exec
              if hasattr(os, 'set_inheritable'):
                  set_inheritable = os.set_inheritable
              else:
                  set_inheritable = lambda i, v: True
              if hasattr(os, 'closerange'):
                  keep = sorted(keep)
                  min_keep = min(keep)
                  max_keep = max(keep)
                  os.closerange(3, min_keep)
                  os.closerange(max_keep + 1, MAXFD)
                  for i in xrange(min_keep, max_keep):
                      if i in keep:
                          set_inheritable(i, True)
                          continue
  
                      try:
                          os.close(i)
                      except:
                          pass
              else:
                  for i in xrange(3, MAXFD):
                      if i in keep:
                          set_inheritable(i, True)
                          continue
                      try:
                          os.close(i)
                      except:
                          pass
  
          def _execute_child(self, args, executable, preexec_fn, close_fds,
                             pass_fds, cwd, env, universal_newlines,
                             startupinfo, creationflags, shell,
                             p2cread, p2cwrite,
                             c2pread, c2pwrite,
                             errread, errwrite,
                             restore_signals, start_new_session):
              """Execute program (POSIX version)"""
  
              if PY3 and isinstance(args, (str, bytes)):
                  args = [args]
              elif not PY3 and isinstance(args, string_types):
                  args = [args]
              else:
                  args = list(args)
  
              if shell:
                  args = ["/bin/sh", "-c"] + args
                  if executable:
                      args[0] = executable
  
              if executable is None:
                  executable = args[0]
  
              self._loop.install_sigchld()
  
              # For transferring possible exec failure from child to parent
              # The first char specifies the exception type: 0 means
              # OSError, 1 means some other error.
              errpipe_read, errpipe_write = self.pipe_cloexec()
              # errpipe_write must not be in the standard io 0, 1, or 2 fd range.
              low_fds_to_close = []
              while errpipe_write < 3:
                  low_fds_to_close.append(errpipe_write)
                  errpipe_write = os.dup(errpipe_write)
              for low_fd in low_fds_to_close:
                  os.close(low_fd)
              try:
                  try:
                      gc_was_enabled = gc.isenabled()
                      # Disable gc to avoid bug where gc -> file_dealloc ->
                      # write to stderr -> hang.  http://bugs.python.org/issue1336
                      gc.disable()
                      try:
                          self.pid = fork_and_watch(self._on_child, self._loop, True, fork)
                      except:
                          if gc_was_enabled:
                              gc.enable()
                          raise
                      if self.pid == 0:
                          # Child
                          try:
                              # Close parent's pipe ends
                              if p2cwrite is not None:
                                  os.close(p2cwrite)
                              if c2pread is not None:
                                  os.close(c2pread)
                              if errread is not None:
                                  os.close(errread)
                              os.close(errpipe_read)
  
                              # When duping fds, if there arises a situation
                              # where one of the fds is either 0, 1 or 2, it
                              # is possible that it is overwritten (#12607).
                              if c2pwrite == 0:
                                  c2pwrite = os.dup(c2pwrite)
                              if errwrite == 0 or errwrite == 1:
                                  errwrite = os.dup(errwrite)
  
                              # Dup fds for child
                              def _dup2(a, b):
                                  # dup2() removes the CLOEXEC flag but
                                  # we must do it ourselves if dup2()
                                  # would be a no-op (issue #10806).
                                  if a == b:
                                      self._set_cloexec_flag(a, False)
                                  elif a is not None:
                                      os.dup2(a, b)
                                  self._remove_nonblock_flag(b)
                              _dup2(p2cread, 0)
                              _dup2(c2pwrite, 1)
                              _dup2(errwrite, 2)
  
                              # Close pipe fds.  Make sure we don't close the
                              # same fd more than once, or standard fds.
                              closed = set([None])
                              for fd in [p2cread, c2pwrite, errwrite]:
                                  if fd not in closed and fd > 2:
                                      os.close(fd)
                                      closed.add(fd)
  
                              if cwd is not None:
                                  os.chdir(cwd)
  
                              if preexec_fn:
                                  preexec_fn()
  
                              # Close all other fds, if asked for. This must be done
                              # after preexec_fn runs.
                              if close_fds:
                                  fds_to_keep = set(pass_fds)
                                  fds_to_keep.add(errpipe_write)
                                  self._close_fds(fds_to_keep)
                              elif hasattr(os, 'get_inheritable'):
                                  # close_fds was false, and we're on
                                  # Python 3.4 or newer, so "all file
                                  # descriptors except standard streams
                                  # are closed, and inheritable handles
                                  # are only inherited if the close_fds
                                  # parameter is False."
                                  for i in xrange(3, MAXFD):
                                      try:
                                          if i == errpipe_write or os.get_inheritable(i):
                                              continue
                                          os.close(i)
                                      except:
                                          pass
  
                              if restore_signals:
                                  # restore the documented signals back to sig_dfl;
                                  # not all will be defined on every platform
                                  for sig in 'SIGPIPE', 'SIGXFZ', 'SIGXFSZ':
                                      sig = getattr(signal, sig, None)
                                      if sig is not None:
                                          signal.signal(sig, signal.SIG_DFL)
  
                              if start_new_session:
                                  os.setsid()
  
                              if env is None:
                                  os.execvp(executable, args)
                              else:
                                  if PY3:
                                      # Python 3.6 started testing for
                                      # bytes values in the env; it also
                                      # started encoding strs using
                                      # fsencode and using a lower-level
                                      # API that takes a list of keys
                                      # and values. We don't have access
                                      # to that API, so we go the reverse direction.
                                      env = {os.fsdecode(k) if isinstance(k, bytes) else k:
                                             os.fsdecode(v) if isinstance(v, bytes) else v
                                             for k, v in env.items()}
                                  os.execvpe(executable, args, env)
  
                          except:
                              exc_type, exc_value, tb = sys.exc_info()
                              # Save the traceback and attach it to the exception object
                              exc_lines = traceback.format_exception(exc_type,
                                                                     exc_value,
                                                                     tb)
                              exc_value.child_traceback = ''.join(exc_lines)
                              os.write(errpipe_write, pickle.dumps(exc_value))
  
                          finally:
                              # Make sure that the process exits no matter what.
                              # The return code does not matter much as it won't be
                              # reported to the application
                              os._exit(1)
  
                      # Parent
                      self._child_created = True
                      if gc_was_enabled:
                          gc.enable()
                  finally:
                      # be sure the FD is closed no matter what
                      os.close(errpipe_write)
  
                  # self._devnull is not always defined.
                  devnull_fd = getattr(self, '_devnull', None)
                  if p2cread is not None and p2cwrite is not None and p2cread != devnull_fd:
                      os.close(p2cread)
                  if c2pwrite is not None and c2pread is not None and c2pwrite != devnull_fd:
                      os.close(c2pwrite)
                  if errwrite is not None and errread is not None and errwrite != devnull_fd:
                      os.close(errwrite)
                  if devnull_fd is not None:
                      os.close(devnull_fd)
                  # Prevent a double close of these fds from __init__ on error.
                  self._closed_child_pipe_fds = True
  
                  # Wait for exec to fail or succeed; possibly raising exception
                  errpipe_read = FileObject(errpipe_read, 'rb')
                  data = errpipe_read.read()
              finally:
                  if hasattr(errpipe_read, 'close'):
                      errpipe_read.close()
                  else:
                      os.close(errpipe_read)
  
              if data != b"":
                  self.wait()
                  child_exception = pickle.loads(data)
                  for fd in (p2cwrite, c2pread, errread):
                      if fd is not None:
                          os.close(fd)
                  raise child_exception
  
          def _handle_exitstatus(self, sts):
              if os.WIFSIGNALED(sts):
                  self.returncode = -os.WTERMSIG(sts)
              elif os.WIFEXITED(sts):
                  self.returncode = os.WEXITSTATUS(sts)
              else:
                  # Should never happen
                  raise RuntimeError("Unknown child exit status!")
  
          def _internal_poll(self):
              """Check if child process has terminated.  Returns returncode
              attribute.
              """
              if self.returncode is None:
                  if get_hub() is not getcurrent():
                      sig_pending = getattr(self._loop, 'sig_pending', True)
                      if sig_pending:
                          sleep(0.00001)
              return self.returncode
  
          def wait(self, timeout=None, _raise_exc=PY3):
              """
              Wait for child process to terminate.  Returns :attr:`returncode`
              attribute.
  
              :keyword timeout: The floating point number of seconds to
                  wait. Under Python 2, this is a gevent extension, and
                  we simply return if it expires. Under Python 3, if
                  this time elapses without finishing the process,
                  :exc:`TimeoutExpired` is raised.
              """
              return self._gevent_result_wait(timeout, _raise_exc)
  
          def send_signal(self, sig):
              """Send a signal to the process
              """
              # Skip signalling a process that we know has already died.
              if self.returncode is None:
                  os.kill(self.pid, sig)
  
          def terminate(self):
              """Terminate the process with SIGTERM
              """
              self.send_signal(signal.SIGTERM)
  
          def kill(self):
              """Kill the process with SIGKILL
              """
              self.send_signal(signal.SIGKILL)
  
  
  def write_and_close(fobj, data):
      try:
          if data:
              fobj.write(data)
              if hasattr(fobj, 'flush'):
                  # 3.6 started expecting flush to be called.
                  fobj.flush()
      except (OSError, IOError) as ex:
          if ex.errno != errno.EPIPE and ex.errno != errno.EINVAL:
              raise
      finally:
          try:
              fobj.close()
          except EnvironmentError:
              pass
  
  def _with_stdout_stderr(exc, stderr):
      # Prior to Python 3.5, most exceptions didn't have stdout
      # and stderr attributes and can't take the stderr attribute in their
      # constructor
      exc.stdout = exc.output
      exc.stderr = stderr
      return exc
  
  class CompletedProcess(object):
      """
      A process that has finished running.
  
      This is returned by run().
  
      Attributes:
        - args: The list or str args passed to run().
        - returncode: The exit code of the process, negative for signals.
        - stdout: The standard output (None if not captured).
        - stderr: The standard error (None if not captured).
  
      .. versionadded:: 1.2a1
         This first appeared in Python 3.5 and is available to all
         Python versions in gevent.
      """
      def __init__(self, args, returncode, stdout=None, stderr=None):
          self.args = args
          self.returncode = returncode
          self.stdout = stdout
          self.stderr = stderr
  
      def __repr__(self):
          args = ['args={!r}'.format(self.args),
                  'returncode={!r}'.format(self.returncode)]
          if self.stdout is not None:
              args.append('stdout={!r}'.format(self.stdout))
          if self.stderr is not None:
              args.append('stderr={!r}'.format(self.stderr))
          return "{}({})".format(type(self).__name__, ', '.join(args))
  
      def check_returncode(self):
          """Raise CalledProcessError if the exit code is non-zero."""
          if self.returncode:
              raise _with_stdout_stderr(CalledProcessError(self.returncode, self.args, self.stdout), self.stderr)
  
  
  def run(*popenargs, **kwargs):
      """
      run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False) -> CompletedProcess
  
      Run command with arguments and return a CompletedProcess instance.
  
      The returned instance will have attributes args, returncode, stdout and
      stderr. By default, stdout and stderr are not captured, and those attributes
      will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them.
      If check is True and the exit code was non-zero, it raises a
      CalledProcessError. The CalledProcessError object will have the return code
      in the returncode attribute, and output & stderr attributes if those streams
      were captured.
  
      If timeout is given, and the process takes too long, a TimeoutExpired
      exception will be raised.
  
      There is an optional argument "input", allowing you to
      pass a string to the subprocess's stdin.  If you use this argument
      you may not also use the Popen constructor's "stdin" argument, as
      it will be used internally.
      The other arguments are the same as for the Popen constructor.
      If universal_newlines=True is passed, the "input" argument must be a
      string and stdout/stderr in the returned object will be strings rather than
      bytes.
  
      .. versionadded:: 1.2a1
         This function first appeared in Python 3.5. It is available on all Python
         versions gevent supports.
      """
      input = kwargs.pop('input', None)
      timeout = kwargs.pop('timeout', None)
      check = kwargs.pop('check', False)
  
      if input is not None:
          if 'stdin' in kwargs:
              raise ValueError('stdin and input arguments may not both be used.')
          kwargs['stdin'] = PIPE
  
      with Popen(*popenargs, **kwargs) as process:
          try:
              stdout, stderr = process.communicate(input, timeout=timeout)
          except TimeoutExpired:
              process.kill()
              stdout, stderr = process.communicate()
              raise _with_stdout_stderr(TimeoutExpired(process.args, timeout, output=stdout), stderr)
          except:
              process.kill()
              process.wait()
              raise
          retcode = process.poll()
          if check and retcode:
              raise _with_stdout_stderr(CalledProcessError(retcode, process.args, stdout), stderr)
  
      return CompletedProcess(process.args, retcode, stdout, stderr)
  