class Popen(object):

def __init__(self, args, bufsize=0, executable=None,

             stdin=None, stdout=None, stderr=None,

             preexec_fn=None, close_fds=False, shell=False,

             cwd=None, env=None, universal_newlines=False,

             startupinfo=None, creationflags=0):

    """Create new Popen instance."""

    _cleanup()

    if not isinstance(bufsize, (int, long)):

        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 close_fds:

            raise ValueError("close_fds is not supported on Windows "

                             "platforms")

    else:

        # POSIX

        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")

    self.stdin = None

    self.stdout = None

    self.stderr = None

    self.pid = None

    self.returncode = None

    self.universal_newlines = universal_newlines

    # 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)

    self._execute_child(args, executable, preexec_fn, close_fds,

                        cwd, env, universal_newlines,

                        startupinfo, creationflags, shell,

                        p2cread, p2cwrite,

                        c2pread, c2pwrite,

                        errread, errwrite)

    if p2cwrite:

        self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)

    if c2pread:

        if universal_newlines:

            self.stdout = os.fdopen(c2pread, 'rU', bufsize)

        else:

            self.stdout = os.fdopen(c2pread, 'rb', bufsize)

    if errread:

        if universal_newlines:

            self.stderr = os.fdopen(errread, 'rU', bufsize)

        else:

            self.stderr = os.fdopen(errread, 'rb', bufsize)

    _active.append(self)

def communicate(self, input=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)."""

    read_set = []

    write_set = []

    stdout = None # Return

    stderr = None # Return

    if self.stdin:

        # Flush stdio buffer.  This might block, if the user has

        # been writing to .stdin in an uncontrolled fashion.

        self.stdin.flush()

        if input:

            write_set.append(self.stdin)

        else:

            self.stdin.close()

    if self.stdout:

        read_set.append(self.stdout)

        stdout = []

    if self.stderr:

        read_set.append(self.stderr)

        stderr = []

    while read_set or write_set:

        rlist, wlist, xlist = select.select(read_set, write_set, [])

        if self.stdin in wlist:

            # When select has indicated that the file is writable,

            # we can write up to PIPE_BUF bytes without risk

            # blocking.  POSIX defines PIPE_BUF >= 512

            bytes_written = os.write(self.stdin.fileno(), input[:512])

            input = input[bytes_written:]

            if not input:

                self.stdin.close()

                write_set.remove(self.stdin)

        if self.stdout in rlist:

            data = os.read(self.stdout.fileno(), 1024)

            if data == "":

                self.stdout.close()

                read_set.remove(self.stdout)

            stdout.append(data)

        if self.stderr in rlist:

            data = os.read(self.stderr.fileno(), 1024)

            if data == "":

                self.stderr.close()

                read_set.remove(self.stderr)

            stderr.append(data)

    # All data exchanged.  Translate lists into strings.

    if stdout != None:

        stdout = ''.join(stdout)

    if stderr != None:

        stderr = ''.join(stderr)

    # Translate newlines, if requested.  We cannot let the file

    # object do the translation: It is based on stdio, which is

    # impossible to combine with select (unless forcing no

    # buffering).

    if self.universal_newlines and hasattr(open, 'newlines'):

        if stdout:

            stdout = self._translate_newlines(stdout)

        if stderr:

            stderr = self._translate_newlines(stderr)

    self.wait()

    return (stdout, stderr)

def poll(self):

    """Check if child process has terminated.  Returns returncode

            attribute."""

    if self.returncode == None:

        try:

            pid, sts = os.waitpid(self.pid, os.WNOHANG)

            if pid == self.pid:

                self._handle_exitstatus(sts)

        except os.error:

            pass

    return self.returncode

def wait(self):

    """Wait for child process to terminate.  Returns returncode

            attribute."""

    if self.returncode == None:

        pid, sts = os.waitpid(self.pid, 0)

        self._handle_exitstatus(sts)

    return self.returncode