"""

        return self.changed, self.added, self.removed

    @LazyProperty

    def tags(self):

        _tags = []

        for tname, tsha in self.repository.tags.iteritems():

            if tsha == self.raw_id:

                _tags.append(tname)

        return _tags

    @LazyProperty

    def branch(self):

        # Note: This function will return one branch name for the changeset -

        # that might not make sense in Git where branches() is a better match

        # for the basic model

        heads = self.repository._heads(reverse=False)

        ref = heads.get(self._commit.id)

        if ref:

            return safe_unicode(ref)

    @LazyProperty

    def branches(self):

        heads = self.repository._heads(reverse=True)

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed.

        """

        if path.endswith('/'):

            path = path.rstrip('/')

        return path

    def _get_id_for_path(self, path):

        path = safe_str(path)

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if path not in self._paths:

            path = path.strip('/')

            # set root tree

            tree = self.repository._repo[self._tree_id]

            if path == '':

                self._paths[''] = tree.id

                return tree.id

            splitted = path.split('/')

            dirs, name = splitted[:-1], splitted[-1]

            curdir = ''

        return stdout, stderr

    def run_git_command(self, cmd):

        """

        Runs given ``cmd`` as git command with cwd set to current repo.

        Returns stdout as unicode str ... or raise RepositoryError.

        """

        cwd = None

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

            cwd = self.path

        stdout, _stderr = self._run_git_command(cmd, cwd=cwd)

        return safe_unicode(stdout)

    @classmethod

    def _check_url(cls, url):

        """

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

        link. Sometimes it may happened that git 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, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

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

            return True

        if url.startswith('git://'):

            return True

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

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

        handlers = []

        url_obj = mercurial.util.url(url)

        test_uri, authinfo = url_obj.authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((mercurial.url.httpbasicauthhandler(passmgr),

                             mercurial.url.httpdigestauthhandler(passmgr)))

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception as e:

            # means it cannot be cloned

            raise urllib2.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        # now detect if it's proper git repo

        gitdata = resp.read()

        if 'service=git-upload-pack' not in gitdata:

            raise urllib2.URLError(

                "url [%s] does not look like an git" % cleaned_uri)

        return True

    def _get_repo(self, create, src_url=None, update_after_clone=False,

                  bare=False):

        if create and os.path.exists(self.path):

            raise RepositoryError("Location already exist")

        if src_url and not create:

            raise RepositoryError("Create should be set to True if src_url is "

                                  "given (clone operation creates repository)")

                return Repo(self.path)

        except (NotGitRepository, OSError) as err:

            raise RepositoryError(err)

    def _get_all_revisions(self):

        # we must check if this repo is not empty, since later command

        # fails if it is. And it's cheaper to ask than throw the subprocess

        # errors

        try:

            self._repo.head()

        except KeyError:

            return []

        rev_filter = settings.GIT_REV_FILTER

        cmd = ['rev-list', rev_filter, '--reverse', '--date-order']

        try:

            so = self.run_git_command(cmd)

        except RepositoryError:

            # Can be raised for empty repositories

            return []

        return so.splitlines()

    def _get_all_revisions2(self):

        # alternate implementation using dulwich

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        Given any revision identifier, returns a 40 char string with revision hash.

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in (None, '', 'tip', 'HEAD', 'head', -1):

            revision = -1

        if isinstance(revision, int):

            try:

                return self.revisions[revision]

            except IndexError:

                msg = ("Revision %s does not exist for %s" % (revision, self))

                raise ChangesetDoesNotExistError(msg)

        if isinstance(revision, (str, unicode)):

            if revision.isdigit() and (len(revision) < 12 or len(revision) == revision.count('0')):

                try:

                    return self.revisions[int(revision)]

                except IndexError:

        except RepositoryError:

            idx_loc = '' if self.bare else '.git'

            # fallback to filesystem

            in_path = os.path.join(self.path, idx_loc, "index")

            he_path = os.path.join(self.path, idx_loc, "HEAD")

            if os.path.exists(in_path):

                return os.stat(in_path).st_mtime

            else:

                return os.stat(he_path).st_mtime

    @LazyProperty

    def description(self):

        return safe_unicode(self._repo.get_description() or b'unknown')

    @LazyProperty

    def contact(self):

        undefined_contact = u'Unknown'

        return undefined_contact

    @property

    def branches(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    @LazyProperty

    def closed_branches(self):

        return {}

    @LazyProperty

    def tags(self):

        return self._get_tags()

    def _get_tags(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        Creates and returns a tag for the given ``revision``.

        :param name: name for new tag

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param revision: changeset id for which new tag would be created

        :param message: message of the tag's commit

        :param date: date of tag's commit

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        if name in self.tags:

            raise TagAlreadyExistError("Tag %s already exists" % name)

        changeset = self.get_changeset(revision)

        message = message or "Added tag %s for commit %s" % (name,

            changeset.raw_id)

        self._repo.refs[b"refs/tags/%s" % name] = changeset._commit.id

        self._parsed_refs = self._get_parsed_refs()

        self.tags = self._get_tags()

                    _refs[_key] = [sha, type_]

                    break

        return _refs

    def _heads(self, reverse=False):

        refs = self._repo.get_refs()

        heads = {}

        for key, val in refs.items():

            for ref_key in [b'refs/heads/', b'refs/remotes/origin/']:

                if key.startswith(ref_key):

                    n = key[len(ref_key):]

                    if n not in [b'HEAD']:

                        heads[n] = val

        return heads if reverse else dict((y, x) for x, y in heads.iteritems())

    def get_changeset(self, revision=None):

        """

        Returns ``GitChangeset`` object representing commit from git repository

        at the given revision or head (most recent commit) if None given.

        """

        if isinstance(revision, GitChangeset):

            return revision

    def get_changesets(self, start=None, end=None, start_date=None,

           end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns iterator of ``GitChangeset`` objects from start to end (both

        are inclusive), in ascending date order (unless ``reverse`` is set).

        :param start: changeset ID, as str; first returned changeset

        :param end: changeset ID, as str; last returned changeset

        :param start_date: if specified, changesets with commit date less than

          ``start_date`` would be filtered out from returned set

        :param end_date: if specified, changesets with commit date greater than

          ``end_date`` would be filtered out from returned set

        :param branch_name: if specified, changesets not reachable from given

          branch would be filtered out from returned set

        :param reverse: if ``True``, returned generator would be reversed

          (meaning that returned changesets would have descending date order)

        :raise BranchDoesNotExistError: If given ``branch_name`` does not

            exist.

        :raise ChangesetDoesNotExistError: If changeset for given ``start`` or

          ``end`` could not be found.

        """

    Mercurial repository backend

    """

    DEFAULT_BRANCH_NAME = 'default'

    scm = 'hg'

    def __init__(self, repo_path, create=False, baseui=None, src_url=None,

                 update_after_clone=False):

        """

        Raises RepositoryError if repository could not be find at the given

        ``repo_path``.

        :param repo_path: local path of the repository

        :param create=False: if set to True, would try to create repository if

           it does not exist rather than raising exception

        :param baseui=None: user data

        :param src_url=None: would try to clone repository from given location

        :param update_after_clone=False: sets update of working copy after

          making a clone

        """

        if not isinstance(repo_path, str):

            raise VCSError('Mercurial backend requires repository path to '

                           'be instance of <str> got %s instead' %

                           type(repo_path))

        self.path = abspath(repo_path)

        self.baseui = baseui or mercurial.ui.ui()

        # We've set path and ui, now we can set _repo itself

        self._repo = self._get_repo(create, src_url, update_after_clone)

    @property

    def _empty(self):

        """

        Checks if repository is empty ie. without any changesets

        """

        # TODO: Following raises errors when using InMemoryChangeset...

        # return len(self._repo.changelog) == 0

        return len(self.revisions) == 0

    @LazyProperty

    def revisions(self):

        """

        Returns list of revisions' ids, in ascending order.  Being lazy

        attribute allows external tools to inject shas from cache.

        """

        return self._get_all_revisions()

    @LazyProperty

    def name(self):

            return True

        url_prefix = None

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

            url_prefix, url = url.split(b'+', 1)

        handlers = []

        url_obj = mercurial.util.url(url)

        test_uri, authinfo = url_obj.authinfo()

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((mercurial.url.httpbasicauthhandler(passmgr),

                             mercurial.url.httpdigestauthhandler(passmgr)))

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('Content-Type', 'application/mercurial-0.1'),

                        ('Accept', 'application/mercurial-0.1')]

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception as e:

            # means it cannot be cloned

            raise urllib2.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

                mercurial.httppeer.instance(repoui or mercurial.ui.ui(), url, False).lookup(b'tip')

            except Exception as e:

                raise urllib2.URLError(

                    "url [%s] does not look like an hg repo org_exc: %s"

                    % (cleaned_uri, e))

        return True

    def _get_repo(self, create, src_url=None, update_after_clone=False):

        """

        Function will check for mercurial repository in given path and return

        a localrepo object. If there is no repository in that path it will

        raise an exception unless ``create`` parameter is set to True - in

        that case repository would be created and returned.

        If ``src_url`` is given, would try to clone repository from the

        location at given clone_point. Additionally it'll make update to

        working copy accordingly to ``update_after_clone`` flag

        """

        try:

            if src_url:

                url = safe_bytes(self._get_url(src_url))

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                MercurialRepository._check_url(url, self.baseui)

                mercurial.commands.clone(self.baseui, url, self.path, **opts)

                # Don't try to create if we've already cloned repo

                create = False

            return mercurial.localrepo.instance(self.baseui, self.path, create=create)

        except (mercurial.error.Abort, mercurial.error.RepoError) as err:

            if create:

                msg = "Cannot create repository at %s. Original error was %s" \

                    % (self.path, err)

            else:

                msg = "Not valid repository at %s. Original error was %s" \

                    % (self.path, err)

            raise RepositoryError(msg)

    @LazyProperty

    def in_memory_changeset(self):

        return MercurialInMemoryChangeset(self)

                yield {"type": name, "extension": ext, "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = safe_str(url)

        if url != 'default' and '://' not in url:

            url = "file:" + urllib.pathname2url(url)

        return url

    def get_hook_location(self):

        """

        returns absolute path to location where hooks are stored

        """

        return os.path.join(self.path, '.hg', '.hgrc')

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

    def get_changesets(self, start=None, end=None, start_date=None,

                       end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns iterator of ``MercurialChangeset`` objects from start to end

        (both are inclusive)

        :param start: None, str, int or mercurial lookup format

        :param end:  None, str, int or mercurial lookup format

        :param start_date:

        :param end_date:

        :param branch_name:

        :param reversed: return changesets in reversed order

        """

        start_raw_id = self._get_revision(start)

        start_pos = None if start is None else self.revisions.index(start_raw_id)

        end_raw_id = self._get_revision(end)

        end_pos = None if end is None else self.revisions.index(end_raw_id)

        if start_pos is not None and end_pos is not None and start_pos > end_pos:

            raise RepositoryError("Start revision '%s' cannot be "

                                  "after end revision '%s'" % (start, end))

        if branch_name and branch_name not in self.allbranches: