starting_values=None, bottomless=False):

        starting_values = starting_values or []

        if bottomless:

            maxlen = int(buffer_size / chunk_size)

        else:

            maxlen = None

        self.data = collections.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

    def throw(self, type, value=None, traceback=None):

        if not self.worker.EOF.is_set():

            raise type(value)

    def start(self):

        self.worker.start()

    def stop(self):

        self.worker.stop()

    def close(self):

        try:

            self.worker.stop()

            self.throw(GeneratorExit)

        except (GeneratorExit, StopIteration):

            pass

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

    # Threaded reader's infrastructure.

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

    @property

    def input(self):

        return self.worker.w

    @property

    def data_added_event(self):

        return self.worker.data_added

    @property

    def data_added(self):

        return self.worker.data_added.is_set()

    @property

    def reading_paused(self):

        return not self.worker.keep_reading.is_set()

    @property

    def done_reading_event(self):

        """

        Done_reading does not mean that the iterator's buffer is empty.

        Iterator might have done reading from underlying source, but the read

        chunks might still be available for serving through .next() method.

        :returns: An threading.Event class instance.

        """

        return self.worker.EOF

    @property

    def done_reading(self):

        """

        Done_reading does not mean that the iterator's buffer is empty.

        Iterator might have done reading from underlying source, but the read

        chunks might still be available for serving through .next() method.

        :returns: An Bool value.

        """

        return self.worker.EOF.is_set()

    @property

    def length(self):

        """

        returns int.

        This is the length of the queue of chunks, not the length of

        the combined contents in those chunks.

                _p = None

            elif err:

                raise EnvironmentError(

                    "Subprocess exited due to an error:\n" + err)

            else:

                raise EnvironmentError(

                    "Subprocess exited with non 0 ret code: %s" % returncode)

        self.process = _p

        self.output = bg_out

        self.error = bg_err

        self.inputstream = inputstream

    def __iter__(self):

        return self

    def next(self):

        if self.process:

            returncode = self.process.poll()

            if (returncode is not None # process has terminated

                and returncode != 0

            ): # and it failed

                self.output.stop()

                self.error.stop()

                err = ''.join(self.error)

                raise EnvironmentError("Subprocess exited due to an error:\n" + err)

        return self.output.next()

    def throw(self, type, value=None, traceback=None):

        if self.output.length or not self.output.done_reading:

            raise type(value)

    def close(self):

        try:

            self.process.terminate()

        except:

            pass

        try:

            self.output.close()

        except:

            pass

        try:

            self.error.close()

        except:

            pass

        try:

            os.close(self.inputstream)

        except:

            pass