cmd.append(settings.GIT_REV_FILTER)

        revs = self.run_git_command(cmd).splitlines()

        start_pos = 0

        end_pos = len(revs)

        if start:

            _start = self._get_revision(start)

            try:

                start_pos = revs.index(_start)

            except ValueError:

                pass

        if end is not None:

            _end = self._get_revision(end)

            try:

                end_pos = revs.index(_end)

            except ValueError:

                pass

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError('start cannot be after end')

        if end_pos is not None:

            end_pos += 1

        revs = revs[start_pos:end_pos]

        if reverse:

            revs.reverse()

        return CollectionGenerator(self, revs)

    def get_diff_changesets(self, org_rev, other_repo, other_rev):

        """

        Returns lists of changesets that can be merged from this repo @org_rev

        to other_repo @other_rev

        ... and the other way

        ... and the ancestors that would be used for merge

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, most likely the fork of org_repo. It has

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        org_changesets = []

        ancestors = None

        if org_rev == other_rev:

            other_changesets = []

        elif self != other_repo:

            gitrepo = Repo(self.path)

            SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)

            gitrepo_remote = Repo(other_repo.path)

            SubprocessGitClient(thin_packs=False).fetch(self.path, gitrepo_remote)

            revs = [

                ascii_str(x.commit.id)

                for x in gitrepo_remote.get_walker(include=[ascii_bytes(other_rev)],

                                                   exclude=[ascii_bytes(org_rev)])

            ]

            other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]

            if other_changesets:

                ancestors = [other_changesets[0].parents[0].raw_id]

            else:

                # no changesets from other repo, ancestor is the other_rev

                ancestors = [other_rev]

            gitrepo.close()

            gitrepo_remote.close()

        else:

            so = self.run_git_command(

                ['log', '--reverse', '--pretty=format:%H',

                 '-s', '%s..%s' % (org_rev, other_rev)]

            )

            other_changesets = [self.get_changeset(cs)

                          for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

            so = self.run_git_command(

                ['merge-base', org_rev, other_rev]

            )

            ancestors = [re.findall(r'[0-9a-fA-F]{40}', so)[0]]

        return other_changesets, org_changesets, ancestors

    def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,

                 context=3):

        """

        Returns (git like) *diff*, as plain bytes text. Shows changes

        introduced by ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

          shown. Defaults to ``3``. Due to limitations in Git, if

          value passed-in is greater than ``2**31-1``

          (``2147483647``), it will be set to ``2147483647``

          instead. If negative value is passed-in, it will be set to

          ``0`` instead.

        """

        # Git internally uses a signed long int for storing context

        # size (number of lines to show before and after the

        # differences). This can result in integer overflow, so we

        # ensure the requested context is smaller by one than the

        # number that would cause the overflow. It is highly unlikely

        # that a single file will contain that many lines, so this

        # kind of change should not cause any realistic consequences.

        overflowed_long_int = 2**31

        if context >= overflowed_long_int:

            context = overflowed_long_int - 1

        # Negative context values make no sense, and will result in

        # errors. Ensure this does not happen.

        if context < 0:

            context = 0

        flags = ['-U%s' % context, '--full-index', '--binary', '-p', '-M', '--abbrev=40']

        if ignore_whitespace:

            flags.append('-w')

        if hasattr(rev1, 'raw_id'):

            rev1 = getattr(rev1, 'raw_id')

        if hasattr(rev2, 'raw_id'):

            rev2 = getattr(rev2, 'raw_id')

        if rev1 == self.EMPTY_CHANGESET:

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ['show'] + flags + [rev2]

        else:

            rev1 = self.get_changeset(rev1).raw_id

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ['diff'] + flags + [rev1, rev2]

        if path:

            cmd += ['--', path]

        stdout, stderr = self._run_git_command(cmd, cwd=self.path)

        # If we used 'show' command, strip first few lines (until actual diff

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            parts = stdout.split(b'\ndiff ', 1)

            if len(parts) > 1:

                stdout = b'diff ' + parts[1]

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

        return inmemory.GitInMemoryChangeset(self)

    def clone(self, url, update_after_clone=True, bare=False):

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

          working directory

        :param bare: If set to ``True``, repository would be cloned into

          *bare* git repository (no working directory at all).

        """

        url = self._get_url(url)

        cmd = ['clone', '-q']

        if bare:

            cmd.append('--bare')

        elif not update_after_clone:

            cmd.append('--no-checkout')

        cmd += ['--', url, self.path]

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        cmd = ['pull', '--ff-only', url]

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def fetch(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        so = self.run_git_command(['ls-remote', '-h', url])

        cmd = ['fetch', url, '--']

            sha, ref = line.split('\t')

            cmd.append('+%s:%s' % (ref, ref))

        self.run_git_command(cmd)

    def _update_server_info(self):

        """

        runs gits update-server-info command in this repo instance

        """

        try:

            update_server_info(self._repo)

        except OSError as e:

            if e.errno not in [errno.ENOENT, errno.EROFS]:

                raise

            # Workaround for dulwich crashing on for example its own dulwich/tests/data/repos/simple_merge.git/info/refs.lock

            log.error('Ignoring %s running update-server-info: %s', type(e).__name__, e)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return workdir.GitWorkdir(self)

    def get_config_value(self, section, name, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, str):

            config_file = [config_file]

        def gen_configs():

            for path in config_file + self._config_files:

                try:

                    yield ConfigFile.from_path(path)

                except (IOError, OSError, ValueError):

                    continue

        for config in gen_configs():

            try:

                value = config.get(section, name)

            except KeyError:

                continue

            return None if value is None else safe_str(value)

        return None

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        return self.get_config_value('user', 'name', config_file)

    def get_user_email(self, config_file=None):

        """

        Returns user's email from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        return self.get_config_value('user', 'email', config_file)