# Compute date

        if date is None:

            date = time.time()

        elif isinstance(date, datetime.datetime):

            date = time.mktime(date.timetuple())

        author_time = kwargs.pop('author_time', date)

        commit.commit_time = int(date)

        commit.author_time = int(author_time)

        tz = time.timezone

        author_tz = kwargs.pop('author_timezone', tz)

        commit.commit_timezone = tz

        commit.author_timezone = author_tz

        object_store.add_object(commit)

        ref = 'refs/heads/%s' % branch

        repo.refs[ref] = commit.id

        repo.refs.set_symbolic_ref('HEAD', ref)

        # Update vcs repository object & recreate dulwich repo

        self.repository.revisions.append(commit.id)

        self.repository._repo = Repo(self.repository.path)

        tip = self.repository.get_changeset()

        self.reset()

        return tip

    def _get_missing_trees(self, path, root_tree):

        """

        Creates missing ``Tree`` objects for the given path.

        :param path: path given as a string. It may be a path to a file node

          (i.e. ``foo/bar/baz.txt``) or directory path - in that case it must

          end with slash (i.e. ``foo/bar/``).

        :param root_tree: ``dulwich.objects.Tree`` object from which we start

          traversing (should be commit's root tree)

        """

        dirpath = posixpath.split(path)[0]

        dirs = dirpath.split('/')

        if not dirs or dirs == ['']:

            return []

        def get_tree_for_dir(tree, dirname):

            for name, mode, id in tree.iteritems():

                if name == dirname:

                    obj = self.repository._repo[id]

                    if isinstance(obj, objects.Tree):

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

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

        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["refs/tags/%s" % name] = changeset._commit.id

        self.tags = self._get_tags()

        return changeset

    def remove_tag(self, name, user, message=None, date=None):

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed

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

        :param message: message of the tag's removal commit

        :param date: date of tag's removal commit

        :raises TagDoesNotExistError: if tag with given name does not exists

        """

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        tagpath = posixpath.join(self._repo.refs.path, 'refs', 'tags', name)

        try:

            os.remove(tagpath)

            self.tags = self._get_tags()

        except OSError, e:

            raise RepositoryError(e.strerror)

    @LazyProperty

    def _parsed_refs(self):

        refs = self._repo.get_refs()

        keys = [('refs/heads/', 'H'),

                ('refs/remotes/origin/', 'RH'),

                ('refs/tags/', 'T')]

        _refs = {}

        for ref, sha in refs.iteritems():

            for k, type_ in keys:

                if ref.startswith(k):

                    _key = ref[len(k):]

                    _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 ['refs/heads/', 'refs/remotes/origin/']:

                if key.startswith(ref_key):

                    n = key[len(ref_key):]

                    if n not in ['HEAD']:

                        heads[n] = val