#    except (EnvironmentError) as e:

    #        print str(e)

    #        raise e

    #

    #    return answer

    """

    def __init__(self, cmd, inputstream=None, buffer_size=65536,

                 chunk_size=4096, starting_values=None, **kwargs):

        """

        Initializes SubprocessIOChunker

        :param cmd: A Subprocess.Popen style "cmd". Can be string or array of strings

        :param inputstream: (Default: None) A file-like, string, or file pointer.

        :param buffer_size: (Default: 65536) A size of total buffer per stream in bytes.

        :param chunk_size: (Default: 4096) A max size of a chunk. Actual chunk may be smaller.

        :param starting_values: (Default: []) An array of strings to put in front of output que.

        """

        starting_values = starting_values or []

        if inputstream:

            input_streamer = StreamFeeder(inputstream)

            input_streamer.start()

            inputstream = input_streamer.output

        # Note: fragile cmd mangling has been removed for use in Kallithea

        assert isinstance(cmd, list), cmd

        _p = subprocess.Popen(cmd, bufsize=-1,

                              stdin=inputstream,

                              stdout=subprocess.PIPE,

                              stderr=subprocess.PIPE,

                              **kwargs)

        bg_out = BufferedGenerator(_p.stdout, buffer_size, chunk_size,

                                   starting_values)

        bg_err = BufferedGenerator(_p.stderr, 16000, 1, bottomless=True)

        while not bg_out.done_reading and not bg_out.reading_paused:

            # doing this until we reach either end of file, or end of buffer.

            bg_out.data_added_event.wait(1)

            bg_out.data_added_event.clear()

        # at this point it's still ambiguous if we are done reading or just full buffer.

        # Either way, if error (returned by ended process, or implied based on

        # presence of stuff in stderr output) we error out.

        # Else, we are happy.

            bg_out.stop()

            out = ''.join(bg_out)

            bg_err.stop()

            err = ''.join(bg_err)

            if (err.strip() == 'fatal: The remote end hung up unexpectedly' and

                out.startswith('0034shallow ')):

                # hack inspired by https://github.com/schacon/grack/pull/7

                bg_out = iter([out])

                _p = None

            elif err:

                raise EnvironmentError(

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

            else:

                raise EnvironmentError(

        self.process = _p

        self.output = bg_out

        self.error = bg_err

        self.inputstream = inputstream

    def __iter__(self):

        return self

    def next(self):

            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

    def __del__(self):

        self.close()