Remove windows python distribution from repo and add requirements.txt

1 files changed, 0 insertions, 1672 deletions

diff --git a/python/gevent/subprocess.py b/python/gevent/subprocess.py
deleted file mode 100644
index e1e28ef..0000000
--- a/python/gevent/subprocess.py
+++ /dev/null
@@ -1,1672 +0,0 @@
-"""
-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_noargs as get_hub
-from gevent.hub import linkproxy
-from gevent.hub import sleep
-from gevent.hub import getcurrent
-from gevent._compat import integer_types, string_types, xrange
-from gevent._compat import PY3
-from gevent._compat import reraise
-from gevent._compat import fspath
-from gevent._compat import fsencode
-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',
-    'STILL_ACTIVE',
-
-    # 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')
-
-if sys.version_info[:2] >= (3, 7):
-    __imports__.extend([
-        'ABOVE_NORMAL_PRIORITY_CLASS', 'BELOW_NORMAL_PRIORITY_CLASS',
-        'HIGH_PRIORITY_CLASS', 'IDLE_PRIORITY_CLASS',
-        'NORMAL_PRIORITY_CLASS',
-        'REALTIME_PRIORITY_CLASS',
-        'CREATE_NO_WINDOW', 'DETACHED_PROCESS',
-        'CREATE_DEFAULT_ERROR_MODE',
-        'CREATE_BREAKAWAY_FROM_JOB'
-    ])
-
-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, None)
-            self.cmd = cmd
-            self.seconds = timeout
-            self.output = output
-
-        @property
-        def timeout(self):
-            return self.seconds
-
-        def __str__(self):
-            return ("Command '%s' timed out after %s seconds" %
-                    (self.cmd, self.timeout))
-
-
-if hasattr(os, 'set_inheritable'):
-    _set_inheritable = os.set_inheritable
-else:
-    _set_inheritable = lambda i, v: True
-
-
-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.
-
-    .. versionchanged:: 1.2b1
-        Add the ``encoding`` and ``errors`` parameters for Python 3.
-
-    .. versionchanged:: 1.3a1
-       Accept "path-like" objects for the *cwd* parameter on all platforms.
-       This was added to Python 3.6. Previously with gevent, it only worked
-       on POSIX platforms on 3.6.
-
-    .. versionchanged:: 1.3a1
-       Add the ``text`` argument as a synonym for ``universal_newlines``,
-       as added on Python 3.7.
-
-    .. versionchanged:: 1.3a2
-       Allow the same keyword arguments under Python 2 as Python 3:
-       ``pass_fds``, ``start_new_session``, ``restore_signals``, ``encoding``
-       and ``errors``. Under Python 2, ``encoding`` and ``errors`` are ignored
-       because native handling of universal newlines is used.
-
-    .. versionchanged:: 1.3a2
-       Under Python 2, ``restore_signals`` defaults to ``False``. Previously it
-       defaulted to ``True``, the same as it did in Python 3.
-    """
-
-    # The value returned from communicate() when there was nothing to read.
-    # Changes if we're in text mode or universal newlines mode.
-    _communicate_empty_value = b''
-
-    def __init__(self, args,
-                 bufsize=-1 if PY3 else 0,
-                 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=None,
-                 startupinfo=None, creationflags=0,
-                 restore_signals=PY3, start_new_session=False,
-                 pass_fds=(),
-                 # Added in 3.6. These are kept as ivars
-                 encoding=None, errors=None,
-                 # Added in 3.7. Not an ivar directly.
-                 text=None,
-                 # gevent additions
-                 threadpool=None):
-
-        self.encoding = encoding
-        self.errors = errors
-
-        hub = get_hub()
-
-        if bufsize is None:
-            # Python 2 doesn't allow None at all, but Python 3 treats
-            # it the same as the default. We do as well.
-            bufsize = -1 if PY3 else 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")
-            if sys.version_info[:2] >= (3, 7):
-                if close_fds is _PLATFORM_DEFAULT_CLOSE_FDS:
-                    close_fds = True
-            else:
-                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
-
-        # Validate the combinations of text and universal_newlines
-        if (text is not None and universal_newlines is not None
-                and bool(universal_newlines) != bool(text)):
-            raise SubprocessError('Cannot disambiguate when both text '
-                                  'and universal_newlines are supplied but '
-                                  'different. Pass one or the other.')
-
-        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 -1 when not using PIPEs. The child objects are -1
-        # 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 != -1:
-                p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
-            if c2pread != -1:
-                c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
-            if errread != -1:
-                errread = msvcrt.open_osfhandle(errread.Detach(), 0)
-
-        text_mode = PY3 and (self.encoding or self.errors or universal_newlines or text)
-        if text_mode or universal_newlines:
-            # Always a native str in universal_newlines mode, even when that
-            # str type is bytes. Additionally, text_mode is only true under
-            # Python 3, so it's actually a unicode str
-            self._communicate_empty_value = ''
-
-        if p2cwrite != -1:
-            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 != -1:
-            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 != -1:
-            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
-        # Convert here for the sake of all platforms. os.chdir accepts
-        # path-like objects natively under 3.6, but CreateProcess
-        # doesn't.
-        cwd = fspath(cwd) if cwd is not None else None
-        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
-        def _make_pipe_reader(pipe_name):
-            pipe = getattr(self, pipe_name)
-            buf_name = '_' + pipe_name + '_buffer'
-
-            def _read():
-                try:
-                    data = pipe.read()
-                except RuntimeError:
-                    return
-                if not data:
-                    return
-                the_buffer = getattr(self, buf_name)
-                if the_buffer:
-                    the_buffer.append(data)
-                else:
-                    setattr(self, buf_name, [data])
-            return _read
-
-        if self.stdout:
-            _read_out = _make_pipe_reader('stdout')
-            stdout = spawn(_read_out)
-            greenlets.append(stdout)
-        else:
-            stdout = None
-
-        if self.stderr:
-            _read_err = _make_pipe_reader('stderr')
-            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)
-
-        for pipe in (self.stdout, self.stderr):
-            if pipe:
-                try:
-                    pipe.close()
-                except RuntimeError:
-                    pass
-
-        self.wait()
-
-        def _get_output_value(pipe_name):
-            buf_name = '_' + pipe_name + '_buffer'
-            buf_value = getattr(self, buf_name)
-            setattr(self, buf_name, None)
-            if buf_value:
-                buf_value = self._communicate_empty_value.join(buf_value)
-            else:
-                buf_value = self._communicate_empty_value
-            return buf_value
-
-        stdout_value = _get_output_value('stdout')
-        stderr_value = _get_output_value('stderr')
-
-        return (None if stdout is None else stdout_value,
-                None if stderr is None else stderr_value)
-
-    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 (-1, -1, -1, -1, -1, -1)
-
-            p2cread, p2cwrite = -1, -1
-            c2pread, c2pwrite = -1, -1
-            errread, errwrite = -1, -1
-
-            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 _filter_handle_list(self, handle_list):
-            """Filter out console handles that can't be used
-            in lpAttributeList["handle_list"] and make sure the list
-            isn't empty. This also removes duplicate handles."""
-            # An handle with it's lowest two bits set might be a special console
-            # handle that if passed in lpAttributeList["handle_list"], will
-            # cause it to fail.
-            # Only works on 3.7+
-            return list({handle for handle in handle_list
-                         if handle & 0x3 != 0x3
-                         or _winapi.GetFileType(handle) !=
-                         _winapi.FILE_TYPE_CHAR})
-
-
-        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()
-            use_std_handles = -1 not in (p2cread, c2pwrite, errwrite)
-            if use_std_handles:
-                startupinfo.dwFlags |= STARTF_USESTDHANDLES
-                startupinfo.hStdInput = p2cread
-                startupinfo.hStdOutput = c2pwrite
-                startupinfo.hStdError = errwrite
-
-            if hasattr(startupinfo, 'lpAttributeList'):
-                # Support for Python >= 3.7
-
-                attribute_list = startupinfo.lpAttributeList
-                have_handle_list = bool(attribute_list and
-                                        "handle_list" in attribute_list and
-                                        attribute_list["handle_list"])
-
-                # If we were given an handle_list or need to create one
-                if have_handle_list or (use_std_handles and close_fds):
-                    if attribute_list is None:
-                        attribute_list = startupinfo.lpAttributeList = {}
-                    handle_list = attribute_list["handle_list"] = \
-                        list(attribute_list.get("handle_list", []))
-
-                    if use_std_handles:
-                        handle_list += [int(p2cread), int(c2pwrite), int(errwrite)]
-
-                    handle_list[:] = self._filter_handle_list(handle_list)
-
-                    if handle_list:
-                        if not close_fds:
-                            import warnings
-                            warnings.warn("startupinfo.lpAttributeList['handle_list'] "
-                                          "overriding close_fds", RuntimeWarning)
-
-                        # When using the handle_list we always request to inherit
-                        # handles but the only handles that will be inherited are
-                        # the ones in the handle_list
-                        close_fds = False
-
-            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
-            """
-            # Don't terminate a process that we know has already died.
-            if self.returncode is not None:
-                return
-            try:
-                TerminateProcess(self._handle, 1)
-            except OSError as e:
-                # ERROR_ACCESS_DENIED (winerror 5) is received when the
-                # process already died.
-                if e.winerror != 5:
-                    raise
-                rc = GetExitCodeProcess(self._handle)
-                if rc == STILL_ACTIVE:
-                    raise
-                self.returncode = rc
-                self.result.set(self.returncode)
-
-        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 = -1, -1
-            c2pread, c2pwrite = -1, -1
-            errread, errwrite = -1, -1
-
-            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:
-                if c2pwrite != -1:
-                    errwrite = c2pwrite
-                else: # child's stdout is not set, use parent's stdout
-                    errwrite = sys.__stdout__.fileno()
-            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
-
-        _POSSIBLE_FD_DIRS = (
-            '/proc/self/fd', # Linux
-            '/dev/fd', # BSD, including macOS
-        )
-
-        @classmethod
-        def _close_fds(cls, keep, errpipe_write):
-            # From the C code:
-            # errpipe_write is part of keep. It must be closed at
-            # exec(), but kept open in the child process until exec() is
-            # called.
-            for path in cls._POSSIBLE_FD_DIRS:
-                if os.path.isdir(path):
-                    return cls._close_fds_from_path(path, keep, errpipe_write)
-            return cls._close_fds_brute_force(keep, errpipe_write)
-
-        @classmethod
-        def _close_fds_from_path(cls, path, keep, errpipe_write):
-            # path names a directory whose only entries have
-            # names that are ascii strings of integers in base10,
-            # corresponding to the fds the current process has open
-            try:
-                fds = [int(fname) for fname in os.listdir(path)]
-            except (ValueError, OSError):
-                cls._close_fds_brute_force(keep, errpipe_write)
-            else:
-                for i in keep:
-                    if i == errpipe_write:
-                        continue
-                    _set_inheritable(i, True)
-
-                for fd in fds:
-                    if fd in keep or fd < 3:
-                        continue
-                    try:
-                        os.close(fd)
-                    except:
-                        pass
-
-        @classmethod
-        def _close_fds_brute_force(cls, keep, errpipe_write):
-            # `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
-
-            # XXX: Bug: We implicitly rely on errpipe_write being the largest open
-            # FD so that we don't change its cloexec flag.
-
-            assert hasattr(os, 'closerange') # Added in 2.7
-            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
-
-        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:
-                try:
-                    args = list(args)
-                except TypeError:  # os.PathLike instead of a sequence?
-                    args = [fsencode(args)]  # os.PathLike -> [str]
-
-            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
-
-                        # XXX: Technically we're doing a lot of stuff here that
-                        # may not be safe to do before a exec(), depending on the OS.
-                        # CPython 3 goes to great lengths to precompute a lot
-                        # of this info before the fork and pass it all to C functions that
-                        # try hard not to call things like malloc(). (Of course,
-                        # CPython 2 pretty much did what we're doing.)
-                        try:
-                            # Close parent's pipe ends
-                            if p2cwrite != -1:
-                                os.close(p2cwrite)
-                            if c2pread != -1:
-                                os.close(c2pread)
-                            if errread != -1:
-                                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)
-                            while errwrite in (0, 1):
-                                errwrite = os.dup(errwrite)
-
-                            # Dup fds for child
-                            def _dup2(existing, desired):
-                                # dup2() removes the CLOEXEC flag but
-                                # we must do it ourselves if dup2()
-                                # would be a no-op (issue #10806).
-                                if existing == desired:
-                                    self._set_cloexec_flag(existing, False)
-                                elif existing != -1:
-                                    os.dup2(existing, desired)
-                                try:
-                                    self._remove_nonblock_flag(desired)
-                                except OSError:
-                                    # Ignore EBADF, it may not actually be
-                                    # open yet.
-                                    # Tested beginning in 3.7.0b3 test_subprocess.py
-                                    pass
-                            _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:
-                                try:
-                                    os.chdir(cwd)
-                                except OSError as e:
-                                    e._failed_chdir = True
-                                    raise
-
-                            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, errpipe_write)
-
-                            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 != -1 and p2cwrite != -1 and p2cread != devnull_fd:
-                    os.close(p2cread)
-                if c2pwrite != -1 and c2pread != -1 and c2pwrite != devnull_fd:
-                    os.close(c2pwrite)
-                if errwrite != -1 and errread != -1 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 and fd != -1:
-                        os.close(fd)
-                if isinstance(child_exception, OSError):
-                    child_exception.filename = executable
-                    if hasattr(child_exception, '_failed_chdir'):
-                        child_exception.filename = cwd
-                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.
-
-    .. versionchanged:: 1.3a2
-       Add the ``capture_output`` argument from Python 3.7. It automatically sets
-       ``stdout`` and ``stderr`` to ``PIPE``. It is an error to pass either
-       of those arguments along with ``capture_output``.
-    """
-    input = kwargs.pop('input', None)
-    timeout = kwargs.pop('timeout', None)
-    check = kwargs.pop('check', False)
-    capture_output = kwargs.pop('capture_output', False)
-
-    if input is not None:
-        if 'stdin' in kwargs:
-            raise ValueError('stdin and input arguments may not both be used.')
-        kwargs['stdin'] = PIPE
-
-    if capture_output:
-        if ('stdout' in kwargs) or ('stderr' in kwargs):
-            raise ValueError('stdout and stderr arguments may not be used '
-                             'with capture_output.')
-        kwargs['stdout'] = PIPE
-        kwargs['stderr'] = 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)