try:

                    dir_id = parent[curdir][1]

                except KeyError:

                    # put curdir back into dirnames and stops

                    dirnames.insert(0, curdir)

                    break

                else:

                    # If found, updates parent

                    parent = self.repository._repo[dir_id]

                    ancestors.append((curdir, parent))

            # Now parent is deepest exising tree and we need to create subtrees

            # for dirnames (in reverse order) [this only applies for nodes from added]

            new_trees = []

            blob = objects.Blob.from_string(node.content.encode(ENCODING))

            node_path = node.name.encode(ENCODING)

            if dirnames:

                # If there are trees which should be created we need to build

                # them now (in reverse order)

                reversed_dirnames = list(reversed(dirnames))

                curtree = objects.Tree()

                curtree[node_path] = node.mode, blob.id

                new_trees.append(curtree)

                for dirname in reversed_dirnames[:-1]:

                    newtree = objects.Tree()

                    #newtree.add(DIRMOD, dirname, curtree.id)

                    newtree[dirname] = DIRMOD, curtree.id

                    new_trees.append(newtree)

                    curtree = newtree

                parent[reversed_dirnames[-1]] = DIRMOD, curtree.id

            else:

                parent.add(name=node_path, mode=node.mode, hexsha=blob.id)

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

                zip(ancestors, ancestors[1:])]):

                parent[path] = DIRMOD, tree.id

                object_store.add_object(tree)

            object_store.add_object(blob)

            for tree in new_trees:

                object_store.add_object(tree)

        for node in self.removed:

            paths = node.path.split('/')

            tree = commit_tree

            trees = [tree]

            # Traverse deep into the forest...

            for path in paths:

                try:

                    obj = self.repository._repo[tree[path][1]]

                    if isinstance(obj, objects.Tree):

                        trees.append(obj)

                        tree = obj

                except KeyError:

                    break

            # Cut down the blob and all rotten trees on the way back...

            for path, tree in reversed(zip(paths, trees)):

                del tree[path]

                if tree:

                    # This tree still has elements - don't remove it or any

                    # of it's parents

                    break

        object_store.add_object(commit_tree)

        # Create commit

        commit = objects.Commit()

        commit.tree = commit_tree.id

        commit.parents = [p._commit.id for p in self.parents if p]

        commit.author = commit.committer = safe_str(author)

        commit.encoding = ENCODING

        commit.message = safe_str(message)

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

                        return obj

                    else:

                        raise RepositoryError("Cannot create directory %s "

                        "at tree %s as path is occupied and is not a "

                        "Tree" % (dirname, tree))

            return None

        trees = []

        parent = root_tree

        for dirname in dirs:

            tree = get_tree_for_dir(parent, dirname)

            if tree is None:

                tree = objects.Tree()

                dirmode = 040000

                parent.add(dirmode, dirname, tree.id)

                parent = tree

            # Always append tree

            trees.append(tree)

        return trees

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

    @LazyProperty

    def tags(self):

        return self._get_tags()

    def _get_tags(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        _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

        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

        revision = self._get_revision(revision)

        changeset = GitChangeset(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 ``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.

        """

        if branch_name and branch_name not in self.branches:

            raise BranchDoesNotExistError("Branch '%s' not found" \

                                          % branch_name)

        # %H at format means (full) commit hash, initial hashes are retrieved

        # in ascending date order

        cmd_template = 'log --date-order --reverse --pretty=format:"%H"'

        cmd_params = {}

        if start_date:

            cmd_template += ' --since "$since"'

            cmd_params['since'] = start_date.strftime('%m/%d/%y %H:%M:%S')

        if end_date:

            cmd_template += ' --until "$until"'

            cmd_params['until'] = end_date.strftime('%m/%d/%y %H:%M:%S')

        if branch_name:

            cmd_template += ' $branch_name'

            cmd_params['branch_name'] = branch_name

        else:

            cmd_template += ' --all'

        cmd = Template(cmd_template).safe_substitute(**cmd_params)

        revs = self.run_git_command(cmd)[0].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