self.keep_reading = Event()

        self.keep_reading.set()

        self.EOF = Event()

        self.EOF.clear()

        self.go = Event()

        self.go.set()

    def stop(self):

        self.go.clear()

        self.EOF.set()

        try:

            # this is not proper, but is done to force the reader thread let

            # go of the input because, if successful, .close() will send EOF

            # down the pipe.

            self.source.close()

        except:

            pass

    def run(self):

        s = self.source

        t = self.target

        cs = self.chunk_size

        ccm = self.chunk_count_max

        kr = self.keep_reading

        da = self.data_added

        go = self.go

        try:

            b = s.read(cs)

        except ValueError:

            b = ''

        while b and go.is_set():

            if len(t) > ccm:

                kr.clear()

                kr.wait(2)

                # # this only works on 2.7.x and up

                # if not kr.wait(10):

                #     raise Exception("Timed out while waiting for input to be read.")

                # instead we'll use this

                if len(t) > ccm + 3:

                    raise IOError(

                        "Timed out while waiting for input from subprocess.")

            t.append(b)

            da.set()

            b = s.read(cs)

        self.EOF.set()

        da.set()  # for cases when done but there was no input.

class BufferedGenerator(object):

    """

    Class behaves as a non-blocking, buffered pipe reader.

    Reads chunks of data (through a thread)

    from a blocking pipe, and attaches these to an array (Deque) of chunks.

    Reading is halted in the thread when max chunks is internally buffered.

    The .next() may operate in blocking or non-blocking fashion by yielding

    '' if no data is ready

    to be sent or by not returning until there is some data to send

    When we get EOF from underlying source pipe we raise the marker to raise

    StopIteration after the last chunk of data is yielded.

    """

    def __init__(self, source, buffer_size=65536, chunk_size=4096,

                 starting_values=[], bottomless=False):

        if bottomless:

            maxlen = int(buffer_size / chunk_size)

        else:

            maxlen = None

        self.data = deque(starting_values, maxlen)

        self.worker = InputStreamChunker(source, self.data, buffer_size,

                                         chunk_size)

        if starting_values:

            self.worker.data_added.set()

        self.worker.start()

    ####################

    # Generator's methods

    ####################

    def __iter__(self):

        return self

    def next(self):

        while not len(self.data) and not self.worker.EOF.is_set():

            self.worker.data_added.clear()

            self.worker.data_added.wait(0.2)

        if len(self.data):

            self.worker.keep_reading.set()

            return _bytes(self.data.popleft())

        elif self.worker.EOF.is_set():

            raise StopIteration