#    return answer

    '''

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

                 chunk_size=4096, starting_values=[], **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.

        '''

        if inputstream:

            input_streamer = StreamFeeder(inputstream)

            input_streamer.start()

            inputstream = input_streamer.output

        if isinstance(cmd, (list, tuple)):

            cmd = ' '.join(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 and not bg_err.length:

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

        _returncode = _p.poll()

        if _returncode or (_returncode == None and bg_err.length):

            try:

                _p.terminate()

            except:

                pass

           at Dulwich (see https://bugs.launchpad.net/bugs/645142). Parsing

           os command's output is road to hell...

        :param cmd: git command to be executed

        """

        _copts = ['-c', 'core.quotepath=false', ]

        _str_cmd = False

        if isinstance(cmd, basestring):

            cmd = [cmd]

            _str_cmd = True

        gitenv = os.environ

        # need to clean fix GIT_DIR !

        if 'GIT_DIR' in gitenv:

            del gitenv['GIT_DIR']

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        cmd = ['git'] + _copts + cmd

        if _str_cmd:

            cmd = ' '.join(cmd)

        try:

            opts = dict(

                env=gitenv,

            )

            if os.path.isdir(self.path):

                opts['cwd'] = self.path

            p = subprocessio.SubprocessIOChunker(cmd, **opts)

        except (EnvironmentError, OSError), err:

            log.error(traceback.format_exc())

            raise RepositoryError("Couldn't run git command (%s).\n"

                                  "Original error was:%s" % (cmd, err))

    @classmethod

    def _check_url(cls, url):

        """

        Functon will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError

        """

        from mercurial.util import url as Url

        # those authnadlers are patched for python 2.6.5 bug an

        # infinit looping when given invalid resources

        from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if('+' in url[:url.find('://')]):

            url = url[url.find('+') + 1:]