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

            revision = self.revisions[-1]

        if ((is_bstr(revision) and revision.isdigit() and len(revision) < 12)

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

            except:

                raise ChangesetDoesNotExistError("Revision %r does not exist "

                    "for this repository %s" % (revision, self))

        elif is_bstr(revision):

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

            _tags_shas = self.tags.values()

            if _ref_revision:  # and _ref_revision[1] in ['H', 'RH', 'T']:

                return _ref_revision[0]

            # maybe it's a tag ? we don't have them in self.revisions

            elif revision in _tags_shas:

                return _tags_shas[_tags_shas.index(revision)]

            elif not pattern.match(revision) or revision not in self.revisions:

                raise ChangesetDoesNotExistError("Revision %r does not exist "

                    "for this repository %s" % (revision, self))

        # Ensure we return full id

        if not pattern.match(str(revision)):

            raise ChangesetDoesNotExistError("Given revision %r not recognized"

                % revision)

        return revision

    def _get_archives(self, archive_name='tip'):

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

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

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

        """

        url = str(url)

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

            url = ':///'.join(('file', url))

        return url

    @LazyProperty

    def name(self):

        return os.path.basename(self.path)

    @LazyProperty

    def last_change(self):

        """

        Returns last change made on this repository as datetime object

        """

        return date_fromtimestamp(self._get_mtime(), makedate()[1])

    def _get_mtime(self):

        try:

            return time.mktime(self.get_changeset().date.timetuple())

        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):

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

        undefined_description = u'unknown'

        description_path = os.path.join(self.path, idx_loc, 'description')

        if os.path.isfile(description_path):

            return safe_unicode(open(description_path).read())

        else:

            return undefined_description

    @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]

        _branches = [(x[0], x[1][0])

                     for x in self._parsed_refs.iteritems() if x[1][1] == 'H']

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

            else:

                return os.stat(st_path).st_mtime

    def _get_hidden(self):

        return self._repo.ui.configbool("web", "hidden", untrusted=True)

    def _get_revision(self, revision):

        """

        Get's an ID revision given as str. This will always return a fill

        40 char revision number

        :param revision: str or int or None

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, 'tip', None]:

            revision = 'tip'

        try:

            revision = hex(self._repo.lookup(revision))

        except (IndexError, ValueError, RepoLookupError, TypeError):

            raise ChangesetDoesNotExistError("Revision %r does not "

                                    "exist for this repository %s" \

                                    % (revision, self))

        return revision

    def _get_archives(self, archive_name='tip'):

        allowed = self.baseui.configlist("web", "allow_archive",

                                         untrusted=True)

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

            if i[0] in allowed or self._repo.ui.configbool("web",

                                                           "allow" + i[0],

                                                           untrusted=True):

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

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

        to filesystem

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

        """

        url = str(url)

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

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

        return url

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

        revision = self._get_revision(revision)

        changeset = MercurialChangeset(repository=self, revision=revision)

        return changeset

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

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

        """

        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 = self.revisions.index(start_raw_id) if start else None

        end_raw_id = self._get_revision(end)

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

        if None not in [start, end] 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.branches.keys():

            raise BranchDoesNotExistError('Such branch %s does not exists for'

                                  ' this repository' % branch_name)

        if end_pos is not None:

            end_pos += 1

        slice_ = reversed(self.revisions[start_pos:end_pos]) if reverse else \

            self.revisions[start_pos:end_pos]

        for id_ in slice_:

            cs = self.get_changeset(id_)

            if branch_name and cs.branch != branch_name:

                continue

            if start_date and cs.date < start_date:

                continue

            if end_date and cs.date > end_date:

                continue

            yield cs

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        try:

            pull(self.baseui, self._repo, url)

        except Abort, err:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return MercurialWorkdir(self)

        """

        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, basestring):

            config_file = [config_file]

        config = self._repo.ui

        for path in config_file:

            config.readconfig(path)

        return config.config(section, name)

    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)

        """

        username = self.get_config_value('ui', 'username')

        if username:

            return author_name(username)

        return None

    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)

        """

        username = self.get_config_value('ui', 'username')

        if username:

            return author_email(username)

        return None