Inside Python subprocess communication

# XXX Rewrite these to use non-blocking I/O on the
# file objects; they are no longer using C stdio!

import subprocess

proc = subprocess.Popen(['ls', '-l'],
                        cwd='/',
                        stdout=subprocess.PIPE)
out, err = proc.communicate()
print(out)

import subprocess

proc = subprocess.Popen('bash',
                        cwd='/',
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE)

out, err = proc.communicate('ls')
print(out)

out, err = proc.communicate('ls -l')

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

   # Optimization: If we are only using one pipe, or no pipe at
   # all, using select() or threads is unnecessary.
   if [self.stdin, self.stdout, self.stderr].count(None) >= 2:
      stdout = None
      stderr = None
      if self.stdin:
         if input:
            self.stdin.write(input)
         self.stdin.close()
      elif self.stdout:
         # This happens in the experiment we ran above
         stdout = self.stdout.read()

         # Note, stdout is closed!
         self.stdout.close()
      elif self.stderr:
         stderr = self.stderr.read()
         self.stderr.close()

      # Waiting until process terminates!
      self.wait()

      return (stdout, stderr)

   # The most interesting case, two or more pipes opened
   # Remember, self is an instance of subprocess.Popen class
   return self._communicate(input)

def _communicate(self, input):
    # there is a historical reason calling this variables "sets"
    # see select.select() (below)
    read_set = []
    write_set = []

    # returned variables
    stdout = None
    stderr = None

    # the tricky part starts right here
    if self.stdin:
        # Flush stdio buffer.  This might block (!), if the user has
        # been writing to .stdin in an uncontrolled fashion.
        self.stdin.flush()

        # Data to be sent to the process through the pipe
        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 = []

    input_offset = 0

    # ...

#...
# while read_set contains self.stdout
# or write_set contains self.stdin
while read_set or write_set:
    try:
       # man select
       # .. select() allows a program to monitor multiple file descriptors,
       # waiting until one or more of the file descriptors become "ready"
       # for some class of I/O operation (e.g., input possible).
       # A file descriptor is  considered ready if it is possible to perform
       # the corresponding I/O operation (e.g., read) without blocking
       rlist, wlist, xlist = select.select(read_set, write_set, [])
    except select.error, e:

       # EINTR means "This call did not succeed because it was interrupted.
       # However, if you try again, it will probably work."
       # In other words, EINTR is not a fatal error, it just means
       # you should retry whatever you were attempting.
       if e.args[0] == errno.EINTR:
           continue
       raise

    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
       chunk = input[input_offset : input_offset + 512]
       bytes_written = os.write(self.stdin.fileno(), chunk)
       input_offset += bytes_written
       if input_offset >= len(input):
          # stdin is closed! It's not possible communicate(input) any more.
          self.stdin.close()
          write_set.remove(self.stdin) # write_set is empty now

    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)

    #...

#...
# The while read_set or write_set: loop ends here
# All data exchanged.  Translate lists into strings.
if stdout is not None:
    stdout = ''.join(stdout) # (stdout) is a list
if stderr is not 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(file, 'newlines'):
    if stdout:
       stdout = self._translate_newlines(stdout)
    if stderr:
       stderr = self._translate_newlines(stderr)

self.wait() # wait until process terminates
return (stdout, stderr)

def wait(self):
    """Wait for child process to terminate.  Returns returncode
    attribute."""
    if self.returncode is None:
        # Try calling a function os.waitpid(self.pid, 0)
        # Ignore Interrupted System Call (errno.EINTR) errors
        pid, sts = _eintr_retry_call(os.waitpid, self.pid, 0)
        self._handle_exitstatus(sts)
    return self.returncode