diff --git a/NEWS b/NEWS
index c2279371..c27ae7ab 100644
--- a/NEWS
+++ b/NEWS
@@ -1,2027 +1,2030 @@
 0.20.0	UNRELEASED
 
  * Drop support for Python 2. (Jelmer Vernooij)
 
+ * Only return files from the loose store that look like git objects.
+   (Nicolas Dandrimont)
+
 0.19.17	UNRELEASED
 
  * Don't break when encountering block devices.
    (Jelmer Vernooij)
 
  * Decode URL paths in HttpGitClient using utf-8 rather than file system
    encoding. (Manuel Jacob)
 
  * Fix pushing from a shallow clone.
    (Brecht Machiels, #705)
 
 0.19.16	2020-04-17
 
  * Don't send "deepen None" to server if graph walker
    supports shallow. (Jelmer Vernooij, #747)
 
  * Support tweaking the compression level for
    loose objects through the "core.looseCompression" and
    "core.compression" settings. (Jelmer Vernooij)
 
  * Support tweaking the compression level for
    pack objects through the "core.packCompression" and
    "core.compression" settings. (Jelmer Vernooij)
 
  * Add a "dulwich.contrib.diffstat" module.
    (Kevin Hendricks)
 
 0.19.15	2020-01-26
 
  * Properly handle files that are just executable for the
    current user. (Jelmer Vernooij, #734)
 
  * Fix handling of stored encoding in
    ``dulwich.porcelain.get_object_by_path`` on Python 3.
    (Jelmer Vernooij)
 
  * Support the include_trees and rename_detector arguments
    at the same time when diffing trees.
    (Jelmer Vernooij)
 
 0.19.14	2019-11-30
 
  * Strip superfluous <> around email. (monnerat)
 
  * Stop checking for ref validity client-side. Users can
    still call check_wants manually. (Jelmer Vernooij)
 
  * Switch over to Google-style docstrings.
    (Jelmer Vernooij)
 
  * Add a ``dulwich.porcelain.active_branch`` function.
    (Jelmer Vernooij)
 
  * Cleanup new directory if clone fails. (Jelmer Vernooij, #733)
 
  * Expand "~" in global exclude path. (Jelmer Vernooij)
 
 0.19.13	2019-08-19
 
  BUG FIXES
 
  * Avoid ``PermissionError``, since it is Python3-specific.
   (Jelmer Vernooij)
 
  * Fix regression that added a dependency on C git for the
    test suite. (Jelmer Vernooij, #720)
 
  * Fix compatibility with Python 3.8 - mostly deprecation warnings.
    (Jelmer Vernooij)
 
 0.19.12	2019-08-13
 
  BUG FIXES
 
  * Update directory detection for `get_unstaged_changes` for Python 3.
    (Boris Feld, #684)
 
  * Add a basic ``porcelain.clean``. (Lane Barlow, #398)
 
  * Fix output format of ``porcelain.diff`` to match that of
    C Git. (Boris Feld)
 
  * Return a 404 not found error when repository is not found.
 
  * Mark ``.git`` directories as hidden on Windows.
    (Martin Packman, #585)
 
  * Implement ``RefsContainer.__iter__``
    (Jelmer Vernooij, #717)
 
  * Don't trust modes if they can't be modified after a file has been created.
    (Jelmer Vernooij, #719)
 
 0.19.11	2019-02-07
 
  IMPROVEMENTS
 
  * Use fullname from gecos field, if available.
    (Jelmer Vernooij)
 
  * Support ``GIT_AUTHOR_NAME`` / ``GIT_AUTHOR_EMAIL``.
    (Jelmer Vernooij)
 
  * Add support for short ids in parse_commit. (Jelmer Vernooij)
 
  * Add support for ``prune`` and ``prune_tags`` arguments
    to ``porcelain.fetch``. (Jelmer Vernooij, #681)
 
  BUG FIXES
 
   * Fix handling of race conditions when new packs appear.
     (Jelmer Vernooij)
 
 0.19.10	2018-01-15
 
  IMPROVEMENTS
 
  * Add `dulwich.porcelain.write_tree`.
    (Jelmer Vernooij)
 
  * Support reading ``MERGE_HEADS`` in ``Repo.do_commit``.
    (Jelmer Vernooij)
 
  * Import from ``collections.abc`` rather than ``collections`` where
    applicable. Required for 3.8 compatibility.
    (Jelmer Vernooij)
 
  * Support plain strings as refspec arguments to
    ``dulwich.porcelain.push``. (Jelmer Vernooij)
 
  * Add support for creating signed tags.
    (Jelmer Vernooij, #542)
 
  BUG FIXES
 
  *  Handle invalid ref that pretends to be a sub-folder under a valid ref.
     (KS Chan)
 
 0.19.9	2018-11-17
 
  BUG FIXES
 
  * Avoid fetching ghosts in ``Repo.fetch``.
    (Jelmer Vernooij)
 
  * Preserve port and username in parsed HTTP URLs.
    (Jelmer Vernooij)
 
  * Add basic server side implementation of ``git-upload-archive``.
    (Jelmer Vernooij)
 
 0.19.8	2018-11-06
 
  * Fix encoding when reading README file in setup.py.
    (egor <egor@sourced.tech>, #668)
 
 0.19.7	2018-11-05
 
  CHANGES
 
   * Drop support for Python 3 < 3.4. This is because
     pkg_resources (which get used by setuptools and mock)
     no longer supports 3.3 and earlier. (Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Support ``depth`` argument to ``GitClient.fetch_pack`` and support
     fetching and updating shallow metadata. (Jelmer Vernooij, #240)
 
  BUG FIXES
 
   * Don't write to stdout and stderr when they are not available
     (such as is the case for pythonw). (Sylvia van Os, #652)
 
   * Fix compatibility with newer versions of git, which expect CONTENT_LENGTH
     to be set to 0 for empty body requests. (Jelmer Vernooij, #657)
 
   * Raise an exception client-side when a caller tries to request
     SHAs that are not directly referenced the servers' refs.
     (Jelmer Vernooij)
 
   * Raise more informative errors when unable to connect to repository
     over SSH or subprocess. (Jelmer Vernooij)
 
   * Handle commit identity fields with multiple ">" characters.
     (Nicolas Dandrimont)
 
  IMPROVEMENTS
 
   * ``dulwich.porcelain.get_object_by_path`` method for easily
     accessing a path in another tree. (Jelmer Vernooij)
 
   * Support the ``i18n.commitEncoding`` setting in config.
     (Jelmer Vernooij)
 
 0.19.6	2018-08-11
 
  BUG FIXES
 
   * Fix support for custom transport arguments in ``dulwich.porcelain.clone``.
     (Semyon Slepov)
 
   * Fix compatibility with Python 3.8 (Jelmer Vernooij, Daniel M. Capella)
 
   * Fix some corner cases in ``path_to_tree_path``. (Romain Keramitas)
 
   * Support paths as bytestrings in various places in ``dulwich.index``
     (Jelmer Vernooij)
 
   * Avoid setup.cfg for now, since it seems to break pypi metadata.
     (Jelmer Vernooij, #658)
 
 0.19.5	2018-07-08
 
  IMPROVEMENTS
 
   * Add ``porcelain.describe``. (Sylvia van Os)
 
  BUG FIXES
 
   * Fix regression in ``dulwich.porcelain.clone`` that prevented cloning
     of remote repositories. (Jelmer Vernooij, #639)
 
   * Don't leave around empty parent directories for removed refs.
     (Damien Tournoud, #640)
 
 0.19.4	2018-06-24
 
  IMPROVEMENTS
 
   * Add ``porcelain.ls_files``. (Jelmer Vernooij)
 
   * Add ``Index.items``. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Avoid unicode characters (e.g. the digraph ij in my surname) in setup.cfg,
     since setuptools doesn't deal well with them. See
     https://github.com/pypa/setuptools/issues/1062. (Jelmer Vernooij, #637)
 
 0.19.3	2018-06-17
 
  IMPROVEMENTS
 
   * Add really basic `dulwich.porcelain.fsck` implementation.
     (Jelmer Vernooij)
 
   * When the `DULWICH_PDB` environment variable is set, make
     SIGQUIT open pdb in the 'dulwich' command.
 
   * Add `checkout` argument to `Repo.clone`.
     (Jelmer Vernooij, #503)
 
   * Add `Repo.get_shallow` method. (Jelmer Vernooij)
 
   * Add basic `dulwich.stash` module. (Jelmer Vernooij)
 
   * Support a `prefix` argument to `dulwich.archive.tar_stream`.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of encoding for tags. (Jelmer Vernooij, #608)
 
   * Fix tutorial tests on Python 3. (Jelmer Vernooij, #573)
 
   * Fix remote refs created by `porcelain.fetch`. (Daniel Andersson, #623)
 
   * More robust pack creation on Windows. (Daniel Andersson)
 
   * Fix recursive option for `porcelain.ls_tree`. (Romain Keramitas)
 
  TESTS
 
   * Some improvements to paramiko tests. (Filipp Frizzy)
 
 0.19.2	2018-04-07
 
  BUG FIXES
 
   * Fix deprecated Index.iterblobs method.
     (Jelmer Vernooij)
 
 0.19.1	2018-04-05
 
  IMPROVEMENTS
 
   * Add 'dulwich.mailmap' file for reading mailmap files.
     (Jelmer Vernooij)
 
   * Dulwich no longer depends on urllib3[secure]. Instead,
     "dulwich[https]" can be used to pull in the necessary
     dependencies for HTTPS support. (Jelmer Vernooij, #616)
 
   * Support the `http.sslVerify` and `http.sslCAInfo`
     configuration options. (Jelmer Vernooij)
 
   * Factor out `dulwich.client.parse_rsync_url` function.
     (Jelmer Vernooij)
 
   * Fix repeat HTTP requests using the same smart HTTP client.
     (Jelmer Vernooij)
 
   * New 'client.PLinkSSHVendor' for creating connections using PuTTY's plink.exe.
     (Adam Bradley, Filipp Frizzy)
 
   * Only pass in `key_filename` and `password` to SSHVendor
     implementations if those parameters are set.
     (This helps with older SSHVendor implementations)
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Index.iterblobs has been renamed to Index.iterobjects.
     (Jelmer Vernooij)
 
 0.19.0	2018-03-10
 
  BUG FIXES
 
   * Make `dulwich.archive` set the gzip header file modification time so that
     archives created from the same Git tree are always identical.
     (#577, Jonas Haag)
 
   * Allow comment characters (#, ;) within configuration file strings
     (Daniel Andersson, #579)
 
   * Raise exception when passing in invalid author/committer values
     to Repo.do_commit(). (Jelmer Vernooij, #602)
 
  IMPROVEMENTS
 
   * Add a fastimport ``extra``. (Jelmer Vernooij)
 
   * Start writing reflog entries. (Jelmer Vernooij)
 
   * Add ability to use password and keyfile ssh options with SSHVendor. (Filipp Kucheryavy)
 
   * Add ``change_type_same`` flag to ``tree_changes``.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * ``GitClient.send_pack`` now accepts a ``generate_pack_data``
     rather than a ``generate_pack_contents`` function for
     performance reasons. (Jelmer Vernooij)
 
   * Dulwich now uses urllib3 internally for HTTP requests.
     The `opener` argument to `dulwich.client.HttpGitClient` that took a
     `urllib2` opener instance has been replaced by a `pool_manager` argument
     that takes a `urllib3` pool manager instance.
     (Daniel Andersson)
 
 0.18.6	2017-11-11
 
  BUG FIXES
 
   * Fix handling of empty repositories in ``porcelain.clone``.
     (#570, Jelmer Vernooij)
 
   * Raise an error when attempting to add paths that are not under the
     repository. (Jelmer Vernooij)
 
   * Fix error message for missing trailing ]. (Daniel Andersson)
 
   * Raise EmptyFileException when corruption (in the form of an empty
     file) is detected. (Antoine R. Dumont, #582)
 
   IMPROVEMENTS
 
   * Enforce date field parsing consistency. This also add checks on
     those date fields for potential overflow.
     (Antoine R. Dumont, #567)
 
 0.18.5	2017-10-29
 
  BUG FIXES
 
   * Fix cwd for hooks. (Fabian Grünbichler)
 
   * Fix setting of origin in config when non-standard origin is passed into
     ``Repo.clone``. (Kenneth Lareau, #565)
 
   * Prevent setting SSH arguments from SSH URLs when using SSH through a
     subprocess. Note that Dulwich doesn't support cloning submodules.
     (CVE-2017-16228) (Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Silently ignored directories in ``Repo.stage``.
     (Jelmer Vernooij, #564)
 
  API CHANGES
 
   * GitFile now raises ``FileLocked`` when encountering a lock
     rather than OSError(EEXIST). (Jelmer Vernooij)
 
 0.18.4	2017-10-01
 
  BUG FIXES
 
   * Make default User-Agent start with "git/" because GitHub won't response to
     HTTP smart server requests otherwise (and reply with a 404).
     (Jelmer vernooij, #562)
 
 0.18.3	2017-09-03
 
  BUG FIXES
 
   * Read config during porcelain operations that involve remotes.
     (Jelmer Vernooij, #545)
 
   * Fix headers of empty chunks in unified diffs. (Taras Postument, #543)
 
   * Properly follow redirects over HTTP. (Jelmer Vernooij, #117)
 
  IMPROVEMENTS
 
   * Add ``dulwich.porcelain.update_head``. (Jelmer Vernooij, #439)
 
   * ``GitClient.fetch_pack`` now returns symrefs.
     (Jelmer Vernooij, #485)
 
   * The server now supports providing symrefs.
     (Jelmer Vernooij, #485)
 
   * Add ``dulwich.object_store.commit_tree_changes`` to incrementally
     commit changes to a tree structure. (Jelmer Vernooij)
 
   * Add basic ``PackBasedObjectStore.repack`` method.
     (Jelmer Vernooij, Earl Chew, #296, #549, #552)
 
 0.18.2	2017-08-01
 
  TEST FIXES
 
   * Use constant timestamp so tests pass in all timezones, not just BST.
     (Jelmer Vernooij)
 
 0.18.1	2017-07-31
 
  BUG FIXES
 
   * Fix syntax error in dulwich.contrib.test_swift_smoke.
     (Jelmer Vernooij)
 
 0.18.0	2017-07-31
 
  BUG FIXES
 
   * Fix remaining tests on Windows. (Jelmer Vernooij, #493)
 
   * Fix build of C extensions with Python 3 on Windows.
     (Jelmer Vernooij)
 
   * Pass 'mkdir' argument onto Repo.init_bare in Repo.clone.
     (Jelmer Vernooij, #504)
 
   * In ``dulwich.porcelain.add``, if no files are specified,
     add from current working directory rather than repository root.
     (Jelmer Vernooij, #521)
 
   * Properly deal with submodules in 'porcelain.status'.
     (Jelmer Vernooij, #517)
 
   * ``dulwich.porcelain.remove`` now actually removes files from
     disk, not just from the index. (Jelmer Vernooij, #488)
 
   * Fix handling of "reset" command with markers and without
     "from". (Antoine Pietri)
 
   * Fix handling of "merge" command with markers. (Antoine Pietri)
 
   * Support treeish argument to porcelain.reset(), rather than
     requiring a ref/commit id. (Jelmer Vernooij)
 
   * Handle race condition when mtime doesn't change between writes/reads.
     (Jelmer Vernooij, #541)
 
   * Fix ``dulwich.porcelain.show`` on commits with Python 3.
     (Jelmer Vernooij, #532)
 
  IMPROVEMENTS
 
   * Add basic support for reading ignore files in ``dulwich.ignore``.
     ``dulwich.porcelain.add`` and ``dulwich.porcelain.status`` now honor
     ignores. (Jelmer Vernooij, Segev Finer, #524, #526)
 
   * New ``dulwich.porcelain.check_ignore`` command.
     (Jelmer Vernooij)
 
   * ``dulwich.porcelain.status`` now supports a ``ignored`` argument.
     (Jelmer Vernooij)
 
  DOCUMENTATION
 
   * Clarified docstrings for Client.{send_pack,fetch_pack} implementations.
     (Jelmer Vernooij, #523)
 
 0.17.3	2017-03-20
 
  PLATFORM SUPPORT
 
   * List Python 3.3 as supported. (Jelmer Vernooij, #513)
 
  BUG FIXES
 
   * Fix compatibility with pypy 3. (Jelmer Vernooij)
 
 0.17.2	2017-03-19
 
  BUG FIXES
 
   * Add workaround for
     https://bitbucket.org/pypy/pypy/issues/2499/cpyext-pystring_asstring-doesnt-work,
     fixing Dulwich when used with C extensions on pypy < 5.6. (Victor Stinner)
 
   * Properly quote config values with a '#' character in them.
     (Jelmer Vernooij, #511)
 
 0.17.1	2017-03-01
 
  IMPROVEMENTS
 
   * Add basic 'dulwich pull' command. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Cope with existing submodules during pull.
     (Jelmer Vernooij, #505)
 
 0.17.0	2017-03-01
 
  TEST FIXES
 
   * Skip test that requires sync to synchronize filesystems if os.sync is
     not available. (Koen Martens)
 
  IMPROVEMENTS
 
   * Implement MemoryRepo.{set_description,get_description}.
     (Jelmer Vernooij)
 
   * Raise exception in Repo.stage() when absolute paths are
     passed in. Allow passing in relative paths to
     porcelain.add().(Jelmer Vernooij)
 
  BUG FIXES
 
   * Handle multi-line quoted values in config files.
     (Jelmer Vernooij, #495)
 
   * Allow porcelain.clone of repository without HEAD.
     (Jelmer Vernooij, #501)
 
   * Support passing tag ids to Walker()'s include argument.
     (Jelmer Vernooij)
 
   * Don't strip trailing newlines from extra headers.
     (Nicolas Dandrimont)
 
   * Set bufsize=0 for subprocess interaction with SSH client.
     Fixes hangs on Python 3. (René Stern, #434)
 
   * Don't drop first slash for SSH paths, except for those
     starting with "~". (Jelmer Vernooij, René Stern, #463)
 
   * Properly log off after retrieving just refs.
     (Jelmer Vernooij)
 
 0.16.3	2016-01-14
 
  TEST FIXES
 
   * Remove racy check that relies on clock time changing between writes.
     (Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Add porcelain.remote_add. (Jelmer Vernooij)
 
 0.16.2	2016-01-14
 
  IMPROVEMENTS
 
   * Fixed failing test-cases on windows.
     (Koen Martens)
 
  API CHANGES
 
   * Repo is now a context manager, so that it can be easily
     closed using a ``with`` statement. (Søren Løvborg)
 
  TEST FIXES
 
   * Only run worktree list compat tests against git 2.7.0,
     when 'git worktree list' was introduced. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Ignore filemode when building index when core.filemode
     is false.
     (Koen Martens)
 
   * Initialize core.filemode configuration setting by
     probing the filesystem for trustable permissions.
     (Koen Martens)
 
   * Fix ``porcelain.reset`` to respect the comittish argument.
     (Koen Martens)
 
   * Fix dulwich.porcelain.ls_remote() on Python 3.
     (#471, Jelmer Vernooij)
 
   * Allow both unicode and byte strings for host paths
     in dulwich.client. (#435, Jelmer Vernooij)
 
   * Add remote from porcelain.clone. (#466, Jelmer Vernooij)
 
   * Fix unquoting of credentials before passing to urllib2.
     (#475, Volodymyr Holovko)
 
   * Cope with submodules in `build_index_from_tree`.
     (#477, Jelmer Vernooij)
 
   * Handle deleted files in `get_unstaged_changes`.
     (#483, Doug Hellmann)
 
   * Don't overwrite files when they haven't changed in
     `build_file_from_blob`.
     (#479, Benoît HERVIER)
 
   * Check for existence of index file before opening pack.
     Fixes a race when new packs are being added.
     (#482, wme)
 
 0.16.1	2016-12-25
 
  BUG FIXES
 
   * Fix python3 compatibility for dulwich.contrib.release_robot.
     (Jelmer Vernooij)
 
 0.16.0	2016-12-24
 
  IMPROVEMENTS
 
   * Add support for worktrees. See `git-worktree(1)` and
     `gitrepository-layout(5)`. (Laurent Rineau)
 
   * Add support for `commondir` file in Git control
     directories. (Laurent Rineau)
 
   * Add support for passwords in HTTP URLs.
     (Jon Bain, Mika Mäenpää)
 
   * Add `release_robot` script to contrib,
     allowing easy finding of current version based on Git tags.
     (Mark Mikofski)
 
   * Add ``Blob.splitlines`` method.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of ``Commit.tree`` being set to an actual
     tree object rather than a tree id. (Jelmer Vernooij)
 
   * Return remote refs from LocalGitClient.fetch_pack(),
     consistent with the documentation for that method.
     (#461, Jelmer Vernooij)
 
   * Fix handling of unknown URL schemes in get_transport_and_path.
     (#465, Jelmer Vernooij)
 
 0.15.0	2016-10-09
 
  BUG FIXES
 
   * Allow missing trailing LF when reading service name from
     HTTP servers. (Jelmer Vernooij, Andrew Shadura, #442)
 
   * Fix dulwich.porcelain.pull() on Python3. (Jelmer Vernooij, #451)
 
   * Properly pull in tags during dulwich.porcelain.clone.
     (Jelmer Vernooij, #408)
 
  CHANGES
 
   * Changed license from "GNU General Public License, version 2.0 or later"
     to "Apache License, version 2.0 or later or GNU General Public License,
     version 2.0 or later". (#153)
 
  IMPROVEMENTS
 
   * Add ``dulwich.porcelain.ls_tree`` implementation. (Jelmer Vernooij)
 
 0.14.1	2016-07-05
 
  BUG FIXES
 
   * Fix regression removing untouched refs when pushing over SSH.
     (Jelmer Vernooij #441)
 
   * Skip Python3 tests for SWIFT contrib module, as it has not yet
     been ported.
 
 0.14.0	2016-07-03
 
  BUG FIXES
 
   * Fix ShaFile.id after modification of a copied ShaFile.
     (Félix Mattrat, Jelmer Vernooij)
 
   * Support removing refs from porcelain.push.
     (Jelmer Vernooij, #437)
 
   * Stop magic protocol ref `capabilities^{}` from leaking out
     to clients. (Jelmer Vernooij, #254)
 
  IMPROVEMENTS
 
   * Add `dulwich.config.parse_submodules` function.
 
   * Add `RefsContainer.follow` method. (#438)
 
 0.13.0	2016-04-24
 
  IMPROVEMENTS
 
   * Support `ssh://` URLs in get_transport_and_path_from_url().
     (Jelmer Vernooij, #402)
 
   * Support missing empty line after headers in Git commits and tags.
     (Nicolas Dandrimont, #413)
 
   * Fix `dulwich.porcelain.status` when used in empty trees.
     (Jelmer Vernooij, #415)
 
   * Return copies of objects in MemoryObjectStore rather than
     references, making the behaviour more consistent with that of
     DiskObjectStore. (Félix Mattrat, Jelmer Vernooij)
 
   * Fix ``dulwich.web`` on Python3. (#295, Jonas Haag)
 
  CHANGES
 
   * Drop support for Python 2.6.
 
   * Fix python3 client web support. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix hang on Gzip decompression. (Jonas Haag)
 
   * Don't rely on working tell() and seek() methods
     on wsgi.input. (Jonas Haag)
 
   * Support fastexport/fastimport functionality on python3 with newer
     versions of fastimport (>= 0.9.5). (Jelmer Vernooij, Félix Mattrat)
 
 0.12.0	2015-12-13
 
  IMPROVEMENTS
 
   * Add a `dulwich.archive` module that can create tarballs.
     Based on code from Jonas Haag in klaus.
 
   * Add a `dulwich.reflog` module for reading and writing reflogs.
     (Jelmer Vernooij)
 
   * Fix handling of ambiguous refs in `parse_ref` to make
     it match the behaviour described in https://git-scm.com/docs/gitrevisions.
     (Chris Bunney)
 
   * Support Python3 in C modules. (Lele Gaifax)
 
  BUG FIXES
 
   * Simplify handling of SSH command invocation.
     Fixes quoting of paths. Thanks, Thomas Liebetraut. (#384)
 
   * Fix inconsistent handling of trailing slashes for DictRefsContainer. (#383)
 
   * Add hack to support thin packs duing fetch(), albeit while requiring the
     entire pack file to be loaded into memory. (jsbain)
 
  CHANGES
 
   * This will be the last release to support Python 2.6.
 
 0.11.2	2015-09-18
 
  IMPROVEMENTS
 
   * Add support for agent= capability. (Jelmer Vernooij, #298)
 
   * Add support for quiet capability. (Jelmer Vernooij)
 
  CHANGES
 
   * The ParamikoSSHVendor class has been moved to
   * dulwich.contrib.paramiko_vendor, as it's currently untested.
     (Jelmer Vernooij, #364)
 
 0.11.1	2015-09-13
 
  Fix-up release to exclude broken blame.py file.
 
 0.11.0	2015-09-13
 
  IMPROVEMENTS
 
   * Extended Python3 support to most of the codebase.
     (Gary van der Merwe, Jelmer Vernooij)
   * The `Repo` object has a new `close` method that can be called to close any
     open resources. (Gary van der Merwe)
   * Support 'git.bat' in SubprocessGitClient on Windows.
     (Stefan Zimmermann)
   * Advertise 'ofs-delta' capability in receive-pack server side
     capabilities. (Jelmer Vernooij)
   * Switched `default_local_git_client_cls` to `LocalGitClient`.
     (Gary van der Merwe)
   * Add `porcelain.ls_remote` and `GitClient.get_refs`.
     (Michael Edgar)
   * Add `Repo.discover` method. (B. M. Corser)
   * Add `dulwich.objectspec.parse_refspec`. (Jelmer Vernooij)
   * Add `porcelain.pack_objects` and `porcelain.repack`.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of 'done' in graph walker and implement the
     'no-done' capability. (Tommy Yu, #88)
 
   * Avoid recursion limit issues resolving deltas. (William Grant, #81)
 
   * Allow arguments in local client binary path overrides.
     (Jelmer Vernooij)
 
   * Fix handling of commands with arguments in paramiko SSH
     client. (Andreas Klöckner, Jelmer Vernooij, #363)
 
   * Fix parsing of quoted strings in configs. (Jelmer Vernooij, #305)
 
 0.10.1  2015-03-25
 
  BUG FIXES
 
   * Return `ApplyDeltaError` when encountering delta errors
     in both C extensions and native delta application code.
     (Jelmer Vernooij, #259)
 
 0.10.0	2015-03-22
 
  BUG FIXES
 
   * In dulwich.index.build_index_from_tree, by default
     refuse to create entries that start with .git/.
 
   * Fix running of testsuite when installed.
     (Jelmer Vernooij, #223)
 
   * Use a block cache in _find_content_rename_candidates(),
     improving performance. (Mike Williams)
 
   * Add support for ``core.protectNTFS`` setting.
     (Jelmer Vernooij)
 
   * Fix TypeError when fetching empty updates.
     (Hwee Miin Koh)
 
   * Resolve delta refs when pulling into a MemoryRepo.
     (Max Shawabkeh, #256)
 
   * Fix handling of tags of non-commits in missing object finder.
     (Augie Fackler, #211)
 
   * Explicitly disable mmap on plan9 where it doesn't work.
     (Jeff Sickel)
 
  IMPROVEMENTS
 
   * New public method `Repo.reset_index`. (Jelmer Vernooij)
 
   * Prevent duplicate parsing of loose files in objects
     directory when reading. Thanks to David Keijser for the
     report. (Jelmer Vernooij, #231)
 
 0.9.9	2015-03-20
 
  SECURITY BUG FIXES
 
   * Fix buffer overflow in C implementation of pack apply_delta().
     (CVE-2015-0838)
 
     Thanks to Ivan Fratric of the Google Security Team for
     reporting this issue.
     (Jelmer Vernooij)
 
 0.9.8	2014-11-30
 
  BUG FIXES
 
   * Various fixes to improve test suite running on Windows.
     (Gary van der Merwe)
 
   * Limit delta copy length to 64K in v2 pack files. (Robert Brown)
 
   * Strip newline from final ACKed SHA while fetching packs.
     (Michael Edgar)
 
   * Remove assignment to PyList_SIZE() that was causing segfaults on
     pypy. (Jelmer Vernooij, #196)
 
  IMPROVEMENTS
 
   * Add porcelain 'receive-pack' and 'upload-pack'. (Jelmer Vernooij)
 
   * Handle SIGINT signals in bin/dulwich. (Jelmer Vernooij)
 
   * Add 'status' support to bin/dulwich. (Jelmer Vernooij)
 
   * Add 'branch_create', 'branch_list', 'branch_delete' porcelain.
     (Jelmer Vernooij)
 
   * Add 'fetch' porcelain. (Jelmer Vernooij)
 
   * Add 'tag_delete' porcelain. (Jelmer Vernooij)
 
   * Add support for serializing/deserializing 'gpgsig' attributes in Commit.
     (Jelmer Vernooij)
 
  CHANGES
 
   * dul-web is now available as 'dulwich web-daemon'.
     (Jelmer Vernooij)
 
   * dulwich.porcelain.tag has been renamed to tag_create.
     dulwich.porcelain.list_tags has been renamed to tag_list.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Restore support for Python 2.6. (Jelmer Vernooij, Gary van der Merwe)
 
 
 0.9.7	2014-06-08
 
  BUG FIXES
 
   * Fix tests dependent on hash ordering. (Michael Edgar)
 
   * Support staging symbolic links in Repo.stage.
     (Robert Brown)
 
   * Ensure that all files object are closed when running the test suite.
     (Gary van der Merwe)
 
   * When writing OFS_DELTA pack entries, write correct offset.
     (Augie Fackler)
 
   * Fix handler of larger copy operations in packs. (Augie Fackler)
 
   * Various fixes to improve test suite running on Windows.
     (Gary van der Merwe)
 
   * Fix logic for extra adds of identical files in rename detector.
     (Robert Brown)
 
  IMPROVEMENTS
 
   * Add porcelain 'status'. (Ryan Faulkner)
 
   * Add porcelain 'daemon'. (Jelmer Vernooij)
 
   * Add `dulwich.greenthreads` module which provides support
     for concurrency of some object store operations.
     (Fabien Boucher)
 
   * Various changes to improve compatibility with Python 3.
     (Gary van der Merwe, Hannu Valtonen, michael-k)
 
   * Add OpenStack Swift backed repository implementation
     in dulwich.contrib. See README.swift for details. (Fabien Boucher)
 
 API CHANGES
 
   * An optional close function can be passed to the Protocol class. This will
     be called by its close method. (Gary van der Merwe)
 
   * All classes with close methods are now context managers, so that they can
     be easily closed using a `with` statement. (Gary van der Merwe)
 
   * Remove deprecated `num_objects` argument to `write_pack` methods.
     (Jelmer Vernooij)
 
  OTHER CHANGES
 
   * The 'dul-daemon' script has been removed. The same functionality
     is now available as 'dulwich daemon'. (Jelmer Vernooij)
 
 0.9.6	2014-04-23
 
  IMPROVEMENTS
 
   * Add support for recursive add in 'git add'.
     (Ryan Faulkner, Jelmer Vernooij)
 
   * Add porcelain 'list_tags'. (Ryan Faulkner)
 
   * Add porcelain 'push'. (Ryan Faulkner)
 
   * Add porcelain 'pull'. (Ryan Faulkner)
 
   * Support 'http.proxy' in HttpGitClient.
     (Jelmer Vernooij, #1096030)
 
   * Support 'http.useragent' in HttpGitClient.
     (Jelmer Vernooij)
 
   * In server, wait for clients to send empty list of
     wants when talking to empty repository.
     (Damien Tournoud)
 
   * Various changes to improve compatibility with
     Python 3. (Gary van der Merwe)
 
  BUG FIXES
 
   * Support unseekable 'wsgi.input' streams.
     (Jonas Haag)
 
   * Raise TypeError when passing unicode() object
     to Repo.__getitem__.
     (Jonas Haag)
 
   * Fix handling of `reset` command in dulwich.fastexport.
     (Jelmer Vernooij, #1249029)
 
   * In client, don't wait for server to close connection
     first. Fixes hang when used against GitHub
     server implementation. (Siddharth Agarwal)
 
   * DeltaChainIterator: fix a corner case where an object is inflated as an
     object already in the repository.
     (Damien Tournoud, #135)
 
   * Stop leaking file handles during pack reload. (Damien Tournoud)
 
   * Avoid reopening packs during pack cache reload. (Jelmer Vernooij)
 
  API CHANGES
 
   * Drop support for Python 2.6. (Jelmer Vernooij)
 
 0.9.5	2014-02-23
 
  IMPROVEMENTS
 
   * Add porcelain 'tag'. (Ryan Faulkner)
 
   * New module `dulwich.objectspec` for parsing strings referencing
     objects and commit ranges. (Jelmer Vernooij)
 
   * Add shallow branch support. (milki)
 
   * Allow passing urllib2 `opener` into HttpGitClient.
     (Dov Feldstern, #909037)
 
  CHANGES
 
   * Drop support for Python 2.4 and 2.5. (Jelmer Vernooij)
 
  API CHANGES
 
   * Remove long deprecated ``Repo.commit``, ``Repo.get_blob``,
     ``Repo.tree`` and ``Repo.tag``. (Jelmer Vernooij)
 
   * Remove long deprecated ``Repo.revision_history`` and ``Repo.ref``.
     (Jelmer Vernooij)
 
   * Remove long deprecated ``Tree.entries``. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Raise KeyError rather than TypeError when passing in
     unicode object of length 20 or 40 to Repo.__getitem__.
     (Jelmer Vernooij)
 
   * Use 'rm' rather than 'unlink' in tests, since the latter
     does not exist on OpenBSD and other platforms.
     (Dmitrij D. Czarkoff)
 
 0.9.4	2013-11-30
 
  IMPROVEMENTS
 
   * Add ssh_kwargs attribute to ParamikoSSHVendor. (milki)
 
   * Add Repo.set_description(). (Víðir Valberg Guðmundsson)
 
   * Add a basic `dulwich.porcelain` module. (Jelmer Vernooij, Marcin Kuzminski)
 
   * Various performance improvements for object access.
     (Jelmer Vernooij)
 
   * New function `get_transport_and_path_from_url`,
     similar to `get_transport_and_path` but only
     supports URLs.
     (Jelmer Vernooij)
 
   * Add support for file:// URLs in `get_transport_and_path_from_url`.
     (Jelmer Vernooij)
 
   * Add LocalGitClient implementation.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Support filesystems with 64bit inode and device numbers.
     (André Roth)
 
  CHANGES
 
   * Ref handling has been moved to dulwich.refs.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Remove long deprecated RefsContainer.set_ref().
     (Jelmer Vernooij)
 
   * Repo.ref() is now deprecated in favour of Repo.refs[].
     (Jelmer Vernooij)
 
 FEATURES
 
   * Add support for graftpoints. (milki)
 
 0.9.3	2013-09-27
 
  BUG FIXES
 
   * Fix path for stdint.h in MANIFEST.in. (Jelmer Vernooij)
 
 0.9.2	2013-09-26
 
  BUG FIXES
 
   * Include stdint.h in MANIFEST.in (Mark Mikofski)
 
 0.9.1	2013-09-22
 
  BUG FIXES
 
   * Support lookups of 40-character refs in BaseRepo.__getitem__. (Chow Loong Jin, Jelmer Vernooij)
 
   * Fix fetching packs with side-band-64k capability disabled. (David Keijser, Jelmer Vernooij)
 
   * Several fixes in send-pack protocol behaviour - handling of empty pack files and deletes.
     (milki, #1063087)
 
   * Fix capability negotiation when fetching packs over HTTP.
     (#1072461, William Grant)
 
   * Enforce determine_wants returning an empty list rather than None. (Fabien Boucher, Jelmer Vernooij)
 
   * In the server, support pushes just removing refs. (Fabien Boucher, Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Support passing a single revision to BaseRepo.get_walker() rather than a list of revisions. 
     (Alberto Ruiz)
 
   * Add `Repo.get_description` method. (Jelmer Vernooij)
 
   * Support thin packs in Pack.iterobjects() and Pack.get_raw().
     (William Grant)
 
   * Add `MemoryObjectStore.add_pack` and `MemoryObjectStore.add_thin_pack` methods.
     (David Bennett)
 
   * Add paramiko-based SSH vendor. (Aaron O'Mullan)
 
   * Support running 'dulwich.server' and 'dulwich.web' using 'python -m'.
     (Jelmer Vernooij)
 
   * Add ObjectStore.close(). (Jelmer Vernooij)
 
   * Raise appropriate NotImplementedError when encountering dumb HTTP servers.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * SSHVendor.connect_ssh has been renamed to SSHVendor.run_command.
     (Jelmer Vernooij)
 
   * ObjectStore.add_pack() now returns a 3-tuple. The last element will be an
     abort() method that can be used to cancel the pack operation.
     (Jelmer Vernooij)
 
 0.9.0	2013-05-31
 
  BUG FIXES
 
   * Push efficiency - report missing objects only. (#562676, Artem Tikhomirov)
 
   * Use indentation consistent with C Git in config files.
     (#1031356, Curt Moore, Jelmer Vernooij)
 
   * Recognize and skip binary files in diff function.
     (Takeshi Kanemoto)
 
   * Fix handling of relative paths in dulwich.client.get_transport_and_path.
     (Brian Visel, #1169368)
 
   * Preserve ordering of entries in configuration.
     (Benjamin Pollack)
 
   * Support ~ expansion in SSH client paths. (milki, #1083439)
 
   * Support relative paths in alternate paths.
     (milki, Michel Lespinasse, #1175007)
 
   * Log all error messages from wsgiref server to the logging module. This
     makes the test suit quiet again. (Gary van der Merwe)
 
   * Support passing None for empty tree in changes_from_tree.
     (Kevin Watters)
 
   * Support fetching empty repository in client. (milki, #1060462)
 
  IMPROVEMENTS:
 
   * Add optional honor_filemode flag to build_index_from_tree.
     (Mark Mikofski)
 
   * Support core/filemode setting when building trees. (Jelmer Vernooij)
 
   * Add chapter on tags in tutorial. (Ryan Faulkner)
 
  FEATURES
 
   * Add support for mergetags. (milki, #963525)
 
   * Add support for posix shell hooks. (milki)
 
 0.8.7	2012-11-27
 
  BUG FIXES
 
   * Fix use of alternates in ``DiskObjectStore``.{__contains__,__iter__}.
     (Dmitriy)
 
   * Fix compatibility with Python 2.4. (David Carr)
 
 0.8.6	2012-11-09
 
  API CHANGES
 
   * dulwich.__init__ no longer imports client, protocol, repo and
     server modules. (Jelmer Vernooij)
 
  FEATURES
 
   * ConfigDict now behaves more like a dictionary.
     (Adam 'Cezar' Jenkins, issue #58)
 
   * HTTPGitApplication now takes an optional
     `fallback_app` argument. (Jonas Haag, issue #67)
 
   * Support for large pack index files. (Jameson Nash)
 
  TESTING
 
   * Make index entry tests a little bit less strict, to cope with
     slightly different behaviour on various platforms.
     (Jelmer Vernooij)
 
   * ``setup.py test`` (available when setuptools is installed) now
     runs all tests, not just the basic unit tests.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Commit._deserialize now actually deserializes the current state rather than
     the previous one. (Yifan Zhang, issue #59)
 
   * Handle None elements in lists of TreeChange objects. (Alex Holmes)
 
   * Support cloning repositories without HEAD set.
     (D-Key, Jelmer Vernooij, issue #69)
 
   * Support ``MemoryRepo.get_config``. (Jelmer Vernooij)
 
   * In ``get_transport_and_path``, pass extra keyword arguments on to
     HttpGitClient. (Jelmer Vernooij)
 
 0.8.5	2012-03-29
 
  BUG FIXES
 
   * Avoid use of 'with' in dulwich.index. (Jelmer Vernooij)
 
   * Be a little bit strict about OS behaviour in index tests.
     Should fix the tests on Debian GNU/kFreeBSD. (Jelmer Vernooij)
 
 0.8.4	2012-03-28
 
  BUG FIXES
 
   * Options on the same line as sections in config files are now supported.
     (Jelmer Vernooij, #920553)
 
   * Only negotiate capabilities that are also supported by the server.
     (Rod Cloutier, Risto Kankkunen)
 
   * Fix parsing of invalid timezone offsets with two minus signs.
     (Jason R. Coombs, #697828)
 
   * Reset environment variables during tests, to avoid
     test isolation leaks reading ~/.gitconfig. (Risto Kankkunen)
 
  TESTS
 
   * $HOME is now explicitly specified for tests that use it to read
     ``~/.gitconfig``, to prevent test isolation issues.
     (Jelmer Vernooij, #920330)
 
  FEATURES
 
   * Additional arguments to get_transport_and_path are now passed
     on to the constructor of the transport. (Sam Vilain)
 
   * The WSGI server now transparently handles when a git client submits data
     using Content-Encoding: gzip.
     (David Blewett, Jelmer Vernooij)
 
   * Add dulwich.index.build_index_from_tree(). (milki)
 
 0.8.3	2012-01-21
 
  FEATURES
 
   * The config parser now supports the git-config file format as
     described in git-config(1) and can write git config files.
     (Jelmer Vernooij, #531092, #768687)
 
   * ``Repo.do_commit`` will now use the user identity from
     .git/config or ~/.gitconfig if none was explicitly specified.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Allow ``determine_wants`` methods to include the zero sha in their
     return value. (Jelmer Vernooij)
 
 0.8.2	2011-12-18
 
  BUG FIXES
 
   * Cope with different zlib buffer sizes in sha1 file parser.
     (Jelmer Vernooij)
 
   * Fix get_transport_and_path for HTTP/HTTPS URLs.
     (Bruno Renié)
 
   * Avoid calling free_objects() on NULL in error cases. (Chris Eberle)
 
   * Fix use --bare argument to 'dulwich init'. (Chris Eberle)
 
   * Properly abort connections when the determine_wants function
     raises an exception. (Jelmer Vernooij, #856769)
 
   * Tweak xcodebuild hack to deal with more error output.
     (Jelmer Vernooij, #903840)
 
  FEATURES
 
   * Add support for retrieving tarballs from remote servers.
     (Jelmer Vernooij, #379087)
 
   * New method ``update_server_info`` which generates data
     for dumb server access. (Jelmer Vernooij, #731235)
 
 0.8.1	2011-10-31
 
  FEATURES
 
   * Repo.do_commit has a new argument 'ref'.
 
   * Repo.do_commit has a new argument 'merge_heads'. (Jelmer Vernooij)
 
   * New ``Repo.get_walker`` method. (Jelmer Vernooij)
 
   * New ``Repo.clone`` method. (Jelmer Vernooij, #725369)
 
   * ``GitClient.send_pack`` now supports the 'side-band-64k' capability.
     (Jelmer Vernooij)
 
   * ``HttpGitClient`` which supports the smart server protocol over
     HTTP. "dumb" access is not yet supported. (Jelmer Vernooij, #373688)
 
   * Add basic support for alternates. (Jelmer Vernooij, #810429)
 
  CHANGES
 
   * unittest2 or python >= 2.7 is now required for the testsuite.
     testtools is no longer supported. (Jelmer Vernooij, #830713)
 
  BUG FIXES
 
   * Fix compilation with older versions of MSVC.  (Martin gz)
 
   * Special case 'refs/stash' as a valid ref. (Jelmer Vernooij, #695577)
 
   * Smart protocol clients can now change refs even if they are
     not uploading new data. (Jelmer Vernooij, #855993)
 
   * Don't compile C extensions when running in pypy.
     (Ronny Pfannschmidt, #881546)
 
   * Use different name for strnlen replacement function to avoid clashing
     with system strnlen. (Jelmer Vernooij, #880362)
 
  API CHANGES
 
   * ``Repo.revision_history`` is now deprecated in favor of ``Repo.get_walker``.
     (Jelmer Vernooij)
 
 0.8.0	2011-08-07
 
  FEATURES
 
   * New DeltaChainIterator abstract class for quickly iterating all objects in
     a pack, with implementations for pack indexing and inflation.
     (Dave Borowitz)
 
   * New walk module with a Walker class for customizable commit walking.
     (Dave Borowitz)
 
   * New tree_changes_for_merge function in diff_tree. (Dave Borowitz)
 
   * Easy rename detection in RenameDetector even without find_copies_harder.
     (Dave Borowitz)
 
  BUG FIXES
 
   * Avoid storing all objects in memory when writing pack.
     (Jelmer Vernooij, #813268)
 
   * Support IPv6 for git:// connections. (Jelmer Vernooij, #801543)
 
   * Improve performance of Repo.revision_history(). (Timo Schmid, #535118)
 
   * Fix use of SubprocessWrapper on Windows. (Paulo Madeira, #670035)
 
   * Fix compilation on newer versions of Mac OS X (Lion and up). (Ryan McKern, #794543)
 
   * Prevent raising ValueError for correct refs in RefContainer.__delitem__.
 
   * Correctly return a tuple from MemoryObjectStore.get_raw. (Dave Borowitz)
 
   * Fix a bug in reading the pack checksum when there are fewer than 20 bytes
     left in the buffer. (Dave Borowitz)
 
   * Support ~ in git:// URL paths. (Jelmer Vernooij, #813555)
 
   * Make ShaFile.__eq__ work when other is not a ShaFile. (Dave Borowitz)
 
   * ObjectStore.get_graph_walker() now no longer yields the same
     revision more than once. This has a significant improvement for
     performance when wide revision graphs are involved.
     (Jelmer Vernooij, #818168)
 
   * Teach ReceivePackHandler how to read empty packs. (Dave Borowitz)
 
   * Don't send a pack with duplicates of the same object. (Dave Borowitz)
 
   * Teach the server how to serve a clone of an empty repo. (Dave Borowitz)
 
   * Correctly advertise capabilities during receive-pack. (Dave Borowitz)
 
   * Fix add/add and add/rename conflicts in tree_changes_for_merge.
     (Dave Borowitz)
 
   * Use correct MIME types in web server. (Dave Borowitz)
 
  API CHANGES
 
   * write_pack no longer takes the num_objects argument and requires an object
     to be passed in that is iterable (rather than an iterator) and that
     provides __len__.  (Jelmer Vernooij)
 
   * write_pack_data has been renamed to write_pack_objects and no longer takes a
     num_objects argument. (Jelmer Vernooij)
 
   * take_msb_bytes, read_zlib_chunks, unpack_objects, and
     PackStreamReader.read_objects now take an additional argument indicating a
     crc32 to compute. (Dave Borowitz)
 
   * PackObjectIterator was removed; its functionality is still exposed by
     PackData.iterobjects. (Dave Borowitz)
 
   * Add a sha arg to write_pack_object to incrementally compute a SHA.
     (Dave Borowitz)
 
   * Include offset in PackStreamReader results. (Dave Borowitz)
 
   * Move PackStreamReader from server to pack. (Dave Borowitz)
 
   * Extract a check_length_and_checksum, compute_file_sha, and
     pack_object_header pack helper functions. (Dave Borowitz)
 
   * Extract a compute_file_sha function. (Dave Borowitz)
 
   * Remove move_in_thin_pack as a separate method; add_thin_pack now completes
     the thin pack and moves it in in one step. Remove ThinPackData as well.
     (Dave Borowitz)
 
   * Custom buffer size in read_zlib_chunks. (Dave Borowitz)
 
   * New UnpackedObject data class that replaces ad-hoc tuples in the return
     value of unpack_object and various DeltaChainIterator methods.
     (Dave Borowitz)
 
   * Add a lookup_path convenience method to Tree. (Dave Borowitz)
 
   * Optionally create RenameDetectors without passing in tree SHAs.
     (Dave Borowitz)
 
   * Optionally include unchanged entries in RenameDetectors. (Dave Borowitz)
 
   * Optionally pass a RenameDetector to tree_changes. (Dave Borowitz)
 
   * Optionally pass a request object through to server handlers. (Dave Borowitz)
 
  TEST CHANGES
 
   * If setuptools is installed, "python setup.py test" will now run the testsuite.
     (Jelmer Vernooij)
 
   * Add a new build_pack test utility for building packs from a simple spec.
     (Dave Borowitz)
 
   * Add a new build_commit_graph test utility for building commits from a
     simple spec. (Dave Borowitz)
 
 0.7.1	2011-04-12
 
  BUG FIXES
 
   * Fix double decref in _diff_tree.c. (Ted Horst, #715528)
 
   * Fix the build on Windows. (Pascal Quantin)
 
   * Fix get_transport_and_path compatibility with pre-2.6.5 versions of Python.
     (Max Bowsher, #707438)
 
   * BaseObjectStore.determine_wants_all no longer breaks on zero SHAs.
     (Jelmer Vernooij)
 
   * write_tree_diff() now supports submodules.
     (Jelmer Vernooij)
 
   * Fix compilation for XCode 4 and older versions of distutils.sysconfig.
     (Daniele Sluijters)
 
  IMPROVEMENTS
 
   * Sphinxified documentation. (Lukasz Balcerzak)
 
   * Add Pack.keep.(Marc Brinkmann)
 
  API CHANGES
 
   * The order of the parameters to Tree.add(name, mode, sha) has changed, and
     is now consistent with the rest of Dulwich. Existing code will still
     work but print a DeprecationWarning. (Jelmer Vernooij, #663550)
 
   * Tree.entries() is now deprecated in favour of Tree.items() and
     Tree.iteritems(). (Jelmer Vernooij)
 
 0.7.0	2011-01-21
 
  FEATURES
 
   * New `dulwich.diff_tree` module for simple content-based rename detection.
     (Dave Borowitz)
 
   * Add Tree.items(). (Jelmer Vernooij)
 
   * Add eof() and unread_pkt_line() methods to Protocol. (Dave Borowitz)
 
   * Add write_tree_diff(). (Jelmer Vernooij)
 
   * Add `serve_command` function for git server commands as executables.
     (Jelmer Vernooij)
 
   * dulwich.client.get_transport_and_path now supports rsync-style repository URLs.
     (Dave Borowitz, #568493)
 
  BUG FIXES
 
   * Correct short-circuiting operation for no-op fetches in the server.
     (Dave Borowitz)
 
   * Support parsing git mbox patches without a version tail, as generated by
     Mercurial.  (Jelmer Vernooij)
 
   * Fix dul-receive-pack and dul-upload-pack. (Jelmer Vernooij)
 
   * Zero-padded file modes in Tree objects no longer trigger an exception but
     the check code warns about them. (Augie Fackler, #581064)
 
   * Repo.init() now honors the mkdir flag. (#671159)
 
   * The ref format is now checked when setting a ref rather than when reading it back.
     (Dave Borowitz, #653527)
 
   * Make sure pack files are closed correctly. (Tay Ray Chuan)
 
  DOCUMENTATION
 
   * Run the tutorial inside the test suite. (Jelmer Vernooij)
 
   * Reorganized and updated the tutorial. (Jelmer Vernooij, Dave Borowitz, #610550,
      #610540)
 
 
 0.6.2	2010-10-16
 
  BUG FIXES
 
   * HTTP server correctly handles empty CONTENT_LENGTH. (Dave Borowitz)
 
   * Don't error when creating GitFiles with the default mode. (Dave Borowitz)
 
   * ThinPackData.from_file now works with resolve_ext_ref callback.
     (Dave Borowitz)
 
   * Provide strnlen() on mingw32 which doesn't have it. (Hans Kolek)
 
   * Set bare=true in the configuratin for bare repositories. (Dirk Neumann)
 
  FEATURES
 
   * Use slots for core objects to save up on memory. (Jelmer Vernooij)
 
   * Web server supports streaming progress/pack output. (Dave Borowitz)
 
   * New public function dulwich.pack.write_pack_header. (Dave Borowitz)
 
   * Distinguish between missing files and read errors in HTTP server.
     (Dave Borowitz)
 
   * Initial work on support for fastimport using python-fastimport.
     (Jelmer Vernooij)
 
   * New dulwich.pack.MemoryPackIndex class. (Jelmer Vernooij)
 
   * Delegate SHA peeling to the object store.  (Dave Borowitz)
 
  TESTS
 
   * Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
 
   * New tests in test_web with better coverage and fewer ad-hoc mocks.
     (Dave Borowitz)
 
   * Standardize quote delimiters in test_protocol. (Dave Borowitz)
 
   * Fix use when testtools is installed. (Jelmer Vernooij)
 
   * Add trivial test for write_pack_header. (Jelmer Vernooij)
 
   * Refactor some of dulwich.tests.compat.server_utils. (Dave Borowitz)
 
   * Allow overwriting id property of objects in test utils. (Dave Borowitz)
 
   * Use real in-memory objects rather than stubs for server tests.
     (Dave Borowitz)
 
   * Clean up MissingObjectFinder. (Dave Borowitz)
 
  API CHANGES
 
   * ObjectStore.iter_tree_contents now walks contents in depth-first, sorted
     order. (Dave Borowitz)
 
   * ObjectStore.iter_tree_contents can optionally yield tree objects as well.
     (Dave Borowitz).
 
   * Add side-band-64k support to ReceivePackHandler. (Dave Borowitz)
 
   * Change server capabilities methods to classmethods. (Dave Borowitz)
 
   * Tweak server handler injection. (Dave Borowitz)
 
   * PackIndex1 and PackIndex2 now subclass FilePackIndex, which is 
     itself a subclass of PackIndex. (Jelmer Vernooij)
 
  DOCUMENTATION
 
   * Add docstrings for various functions in dulwich.objects. (Jelmer Vernooij)
 
   * Clean up docstrings in dulwich.protocol. (Dave Borowitz)
 
   * Explicitly specify allowed protocol commands to
     ProtocolGraphWalker.read_proto_line.  (Dave Borowitz)
 
   * Add utility functions to DictRefsContainer. (Dave Borowitz)
 
 
 0.6.1	2010-07-22
 
  BUG FIXES
 
   * Fix memory leak in C implementation of sorted_tree_items. (Dave Borowitz)
 
   * Use correct path separators for named repo files. (Dave Borowitz)
 
   * python > 2.7 and testtools-based test runners will now also pick up skipped
     tests correctly. (Jelmer Vernooij)
 
  FEATURES
 
   * Move named file initilization to BaseRepo. (Dave Borowitz)
 
   * Add logging utilities and git/HTTP server logging. (Dave Borowitz)
 
   * The GitClient interface has been cleaned up and instances are now reusable.
     (Augie Fackler)
 
   * Allow overriding paths to executables in GitSSHClient. 
     (Ross Light, Jelmer Vernooij, #585204)
 
   * Add PackBasedObjectStore.pack_loose_objects(). (Jelmer Vernooij)
 
  TESTS
 
   * Add tests for sorted_tree_items and C implementation. (Dave Borowitz)
 
   * Add a MemoryRepo that stores everything in memory. (Dave Borowitz)
 
   * Quiet logging output from web tests. (Dave Borowitz)
 
   * More flexible version checking for compat tests. (Dave Borowitz)
 
   * Compat tests for servers with and without side-band-64k. (Dave Borowitz)
 
  CLEANUP
 
   * Clean up file headers. (Dave Borowitz)
 
  TESTS
 
   * Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
 
  API CHANGES
 
   * dulwich.pack.write_pack_index_v{1,2} now take a file-like object
     rather than a filename. (Jelmer Vernooij)
 
   * Make dul-daemon/dul-web trivial wrappers around server functionality.
     (Dave Borowitz)
 
   * Move reference WSGI handler to web.py. (Dave Borowitz)
 
   * Factor out _report_status in ReceivePackHandler. (Dave Borowitz)
 
   * Factor out a function to convert a line to a pkt-line. (Dave Borowitz)
 
 
 0.6.0	2010-05-22
 
 note: This list is most likely incomplete for 0.6.0.
 
  BUG FIXES
  
   * Fix ReceivePackHandler to disallow removing refs without delete-refs.
     (Dave Borowitz)
 
   * Deal with capabilities required by the client, even if they 
     can not be disabled in the server. (Dave Borowitz)
 
   * Fix trailing newlines in generated patch files.
     (Jelmer Vernooij)
 
   * Implement RefsContainer.__contains__. (Jelmer Vernooij)
 
   * Cope with \r in ref files on Windows. (
     http://github.com/jelmer/dulwich/issues/#issue/13, Jelmer Vernooij)
 
   * Fix GitFile breakage on Windows. (Anatoly Techtonik, #557585)
 
   * Support packed ref deletion with no peeled refs. (Augie Fackler)
 
   * Fix send pack when there is nothing to fetch. (Augie Fackler)
 
   * Fix fetch if no progress function is specified. (Augie Fackler)
 
   * Allow double-staging of files that are deleted in the index. 
     (Dave Borowitz)
 
   * Fix RefsContainer.add_if_new to support dangling symrefs.
     (Dave Borowitz)
 
   * Non-existant index files in non-bare repositories are now treated as 
     empty. (Dave Borowitz)
 
   * Always update ShaFile.id when the contents of the object get changed. 
     (Jelmer Vernooij)
 
   * Various Python2.4-compatibility fixes. (Dave Borowitz)
 
   * Fix thin pack handling. (Dave Borowitz)
  
  FEATURES
 
   * Add include-tag capability to server. (Dave Borowitz)
 
   * New dulwich.fastexport module that can generate fastexport 
     streams. (Jelmer Vernooij)
 
   * Implemented BaseRepo.__contains__. (Jelmer Vernooij)
 
   * Add __setitem__ to DictRefsContainer. (Dave Borowitz)
 
   * Overall improvements checking Git objects. (Dave Borowitz)
 
   * Packs are now verified while they are received. (Dave Borowitz)
 
  TESTS
 
   * Add framework for testing compatibility with C Git. (Dave Borowitz)
 
   * Add various tests for the use of non-bare repositories. (Dave Borowitz)
 
   * Cope with diffstat not being available on all platforms. 
     (Tay Ray Chuan, Jelmer Vernooij)
 
   * Add make_object and make_commit convenience functions to test utils.
     (Dave Borowitz)
 
  API BREAKAGES
 
   * The 'committer' and 'message' arguments to Repo.do_commit() have 
     been swapped. 'committer' is now optional. (Jelmer Vernooij)
 
   * Repo.get_blob, Repo.commit, Repo.tag and Repo.tree are now deprecated.
     (Jelmer Vernooij)
 
   * RefsContainer.set_ref() was renamed to RefsContainer.set_symbolic_ref(),
     for clarity. (Jelmer Vernooij)
 
  API CHANGES
 
   * The primary serialization APIs in dulwich.objects now work 
     with chunks of strings rather than with full-text strings. 
     (Jelmer Vernooij)
 
 0.5.02010-03-03
 
  BUG FIXES
 
   * Support custom fields in commits (readonly). (Jelmer Vernooij)
 
   * Improved ref handling. (Dave Borowitz)
 
   * Rework server protocol to be smarter and interoperate with cgit client.
     (Dave Borowitz)
 
   * Add a GitFile class that uses the same locking protocol for writes as 
     cgit. (Dave Borowitz)
 
   * Cope with forward slashes correctly in the index on Windows.
     (Jelmer Vernooij, #526793)
 
  FEATURES
 
   * --pure option to setup.py to allow building/installing without the C 
     extensions. (Hal Wine, Anatoly Techtonik, Jelmer Vernooij, #434326)
 
   * Implement Repo.get_config(). (Jelmer Vernooij, Augie Fackler)
 
   * HTTP dumb and smart server. (Dave Borowitz)
 
   * Add abstract baseclass for Repo that does not require file system 
     operations. (Dave Borowitz)
 
 0.4.1	2010-01-03
 
  FEATURES
 
   * Add ObjectStore.iter_tree_contents(). (Jelmer Vernooij)
 
   * Add Index.changes_from_tree(). (Jelmer Vernooij)
 
   * Add ObjectStore.tree_changes(). (Jelmer Vernooij)
 
   * Add functionality for writing patches in dulwich.patch.
     (Jelmer Vernooij)
 
 0.4.0	2009-10-07
 
  DOCUMENTATION
 
   * Added tutorial.
 
  API CHANGES
 
   * dulwich.object_store.tree_lookup_path will now return the mode and 
     sha of the object found rather than the object itself.
 
  BUG FIXES
 
   * Use binascii.hexlify / binascii.unhexlify for better performance.
 
   * Cope with extra unknown data in index files by ignoring it (for now).
 
   * Add proper error message when server unexpectedly hangs up. (#415843)
 
   * Correctly write opcode for equal in create_delta.
 
 0.3.3	2009-07-23
 
  FEATURES
 
   * Implement ShaFile.__hash__().
 
   * Implement Tree.__len__()
 
  BUG FIXES
   
   * Check for 'objects' and 'refs' directories
     when looking for a Git repository. (#380818)
 
 0.3.2	2009-05-20
 
  BUG FIXES
 
   * Support the encoding field in Commits.
   
   * Some Windows compatibility fixes.
 
   * Fixed several issues in commit support.
 
  FEATURES
 
   * Basic support for handling submodules.
 
 0.3.1	2009-05-13
 
  FEATURES
 
   * Implemented Repo.__getitem__, Repo.__setitem__ and Repo.__delitem__ to 
     access content.
 
  API CHANGES
 
   * Removed Repo.set_ref, Repo.remove_ref, Repo.tags, Repo.get_refs and 
     Repo.heads in favor of Repo.refs, a dictionary-like object for accessing
     refs.
 
  BUG FIXES
 
   * Removed import of 'sha' module in objects.py, which was causing 
     deprecation warnings on Python 2.6.
 
 0.3.0	2009-05-10
 
  FEATURES
 
   * A new function 'commit_tree' has been added that can commit a tree 
     based on an index.
 
  BUG FIXES
 
   * The memory usage when generating indexes has been significantly reduced.
  
   * A memory leak in the C implementation of parse_tree has been fixed.
 
   * The send-pack smart server command now works. (Thanks Scott Chacon)
 
   * The handling of short timestamps (less than 10 digits) has been fixed.
 
   * The handling of timezones has been fixed.
 
 0.2.1	2009-04-30
 
  BUG FIXES
 
   * Fix compatibility with Python2.4.
 
 0.2.0	2009-04-30
 
  FEATURES
 
   * Support for activity reporting in smart protocol client.
 
   * Optional C extensions for better performance in a couple of 
     places that are performance-critical.
 
 0.1.1	2009-03-13
 
  BUG FIXES
 
   * Fixed regression in Repo.find_missing_objects()
 
   * Don't fetch ^{} objects from remote hosts, as requesting them 
     causes a hangup.
 
   * Always write pack to disk completely before calculating checksum.
 
  FEATURES
 
   * Allow disabling thin packs when talking to remote hosts.
 
 0.1.0	2009-01-24
 
   * Initial release.
diff --git a/dulwich/object_store.py b/dulwich/object_store.py
index 0b8f0541..5908b934 100644
--- a/dulwich/object_store.py
+++ b/dulwich/object_store.py
@@ -1,1414 +1,1418 @@
 # object_store.py -- Object store for git objects
 # Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@jelmer.uk>
 #                         and others
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 
 """Git object store interfaces and implementation."""
 
 from io import BytesIO
 import os
 import stat
 import sys
 import tempfile
 
 from dulwich.diff_tree import (
     tree_changes,
     walk_trees,
     )
 from dulwich.errors import (
     NotTreeError,
     )
 from dulwich.file import GitFile
 from dulwich.objects import (
     Commit,
     ShaFile,
     Tag,
     Tree,
     ZERO_SHA,
     hex_to_sha,
     sha_to_hex,
     hex_to_filename,
     S_ISGITLINK,
     object_class,
+    valid_hexsha,
     )
 from dulwich.pack import (
     Pack,
     PackData,
     PackInflater,
     PackFileDisappeared,
     iter_sha1,
     pack_objects_to_data,
     write_pack_header,
     write_pack_index_v2,
     write_pack_data,
     write_pack_object,
     compute_file_sha,
     PackIndexer,
     PackStreamCopier,
     )
 from dulwich.refs import ANNOTATED_TAG_SUFFIX
 
 INFODIR = 'info'
 PACKDIR = 'pack'
 
 
 class BaseObjectStore(object):
     """Object store interface."""
 
     def determine_wants_all(self, refs):
         return [sha for (ref, sha) in refs.items()
                 if sha not in self and
                 not ref.endswith(ANNOTATED_TAG_SUFFIX) and
                 not sha == ZERO_SHA]
 
     def iter_shas(self, shas):
         """Iterate over the objects for the specified shas.
 
         Args:
           shas: Iterable object with SHAs
         Returns: Object iterator
         """
         return ObjectStoreIterator(self, shas)
 
     def contains_loose(self, sha):
         """Check if a particular object is present by SHA1 and is loose."""
         raise NotImplementedError(self.contains_loose)
 
     def contains_packed(self, sha):
         """Check if a particular object is present by SHA1 and is packed."""
         raise NotImplementedError(self.contains_packed)
 
     def __contains__(self, sha):
         """Check if a particular object is present by SHA1.
 
         This method makes no distinction between loose and packed objects.
         """
         return self.contains_packed(sha) or self.contains_loose(sha)
 
     @property
     def packs(self):
         """Iterable of pack objects."""
         raise NotImplementedError
 
     def get_raw(self, name):
         """Obtain the raw text for an object.
 
         Args:
           name: sha for the object.
         Returns: tuple with numeric type and object contents.
         """
         raise NotImplementedError(self.get_raw)
 
     def __getitem__(self, sha):
         """Obtain an object by SHA1."""
         type_num, uncomp = self.get_raw(sha)
         return ShaFile.from_raw_string(type_num, uncomp, sha=sha)
 
     def __iter__(self):
         """Iterate over the SHAs that are present in this store."""
         raise NotImplementedError(self.__iter__)
 
     def add_object(self, obj):
         """Add a single object to this object store.
 
         """
         raise NotImplementedError(self.add_object)
 
     def add_objects(self, objects, progress=None):
         """Add a set of objects to this object store.
 
         Args:
           objects: Iterable over a list of (object, path) tuples
         """
         raise NotImplementedError(self.add_objects)
 
     def add_pack_data(self, count, pack_data, progress=None):
         """Add pack data to this object store.
 
         Args:
           num_items: Number of items to add
           pack_data: Iterator over pack data tuples
         """
         if count == 0:
             # Don't bother writing an empty pack file
             return
         f, commit, abort = self.add_pack()
         try:
             write_pack_data(
                 f, count, pack_data, progress,
                 compression_level=self.pack_compression_level)
         except BaseException:
             abort()
             raise
         else:
             return commit()
 
     def tree_changes(self, source, target, want_unchanged=False,
                      include_trees=False, change_type_same=False,
                      rename_detector=None):
         """Find the differences between the contents of two trees
 
         Args:
           source: SHA1 of the source tree
           target: SHA1 of the target tree
           want_unchanged: Whether unchanged files should be reported
           include_trees: Whether to include trees
           change_type_same: Whether to report files changing
             type in the same entry.
         Returns: Iterator over tuples with
             (oldpath, newpath), (oldmode, newmode), (oldsha, newsha)
         """
         for change in tree_changes(self, source, target,
                                    want_unchanged=want_unchanged,
                                    include_trees=include_trees,
                                    change_type_same=change_type_same,
                                    rename_detector=rename_detector):
             yield ((change.old.path, change.new.path),
                    (change.old.mode, change.new.mode),
                    (change.old.sha, change.new.sha))
 
     def iter_tree_contents(self, tree_id, include_trees=False):
         """Iterate the contents of a tree and all subtrees.
 
         Iteration is depth-first pre-order, as in e.g. os.walk.
 
         Args:
           tree_id: SHA1 of the tree.
           include_trees: If True, include tree objects in the iteration.
         Returns: Iterator over TreeEntry namedtuples for all the objects in a
             tree.
         """
         for entry, _ in walk_trees(self, tree_id, None):
             if ((entry.mode is not None and
                  not stat.S_ISDIR(entry.mode)) or include_trees):
                 yield entry
 
     def find_missing_objects(self, haves, wants, shallow=None, progress=None,
                              get_tagged=None,
                              get_parents=lambda commit: commit.parents,
                              depth=None):
         """Find the missing objects required for a set of revisions.
 
         Args:
           haves: Iterable over SHAs already in common.
           wants: Iterable over SHAs of objects to fetch.
           shallow: Set of shallow commit SHA1s to skip
           progress: Simple progress function that will be called with
             updated progress strings.
           get_tagged: Function that returns a dict of pointed-to sha ->
             tag sha for including tags.
           get_parents: Optional function for getting the parents of a
             commit.
         Returns: Iterator over (sha, path) pairs.
         """
         finder = MissingObjectFinder(self, haves, wants, shallow, progress,
                                      get_tagged, get_parents=get_parents)
         return iter(finder.next, None)
 
     def find_common_revisions(self, graphwalker):
         """Find which revisions this store has in common using graphwalker.
 
         Args:
           graphwalker: A graphwalker object.
         Returns: List of SHAs that are in common
         """
         haves = []
         sha = next(graphwalker)
         while sha:
             if sha in self:
                 haves.append(sha)
                 graphwalker.ack(sha)
             sha = next(graphwalker)
         return haves
 
     def generate_pack_contents(self, have, want, shallow=None, progress=None):
         """Iterate over the contents of a pack file.
 
         Args:
           have: List of SHA1s of objects that should not be sent
           want: List of SHA1s of objects that should be sent
           shallow: Set of shallow commit SHA1s to skip
           progress: Optional progress reporting method
         """
         missing = self.find_missing_objects(have, want, shallow, progress)
         return self.iter_shas(missing)
 
     def generate_pack_data(self, have, want, shallow=None, progress=None,
                            ofs_delta=True):
         """Generate pack data objects for a set of wants/haves.
 
         Args:
           have: List of SHA1s of objects that should not be sent
           want: List of SHA1s of objects that should be sent
           shallow: Set of shallow commit SHA1s to skip
           ofs_delta: Whether OFS deltas can be included
           progress: Optional progress reporting method
         """
         # TODO(jelmer): More efficient implementation
         return pack_objects_to_data(
             self.generate_pack_contents(have, want, shallow, progress))
 
     def peel_sha(self, sha):
         """Peel all tags from a SHA.
 
         Args:
           sha: The object SHA to peel.
         Returns: The fully-peeled SHA1 of a tag object, after peeling all
             intermediate tags; if the original ref does not point to a tag,
             this will equal the original SHA1.
         """
         obj = self[sha]
         obj_class = object_class(obj.type_name)
         while obj_class is Tag:
             obj_class, sha = obj.object
             obj = self[sha]
         return obj
 
     def _collect_ancestors(self, heads, common=set(), shallow=set(),
                            get_parents=lambda commit: commit.parents):
         """Collect all ancestors of heads up to (excluding) those in common.
 
         Args:
           heads: commits to start from
           common: commits to end at, or empty set to walk repository
             completely
           get_parents: Optional function for getting the parents of a
             commit.
         Returns: a tuple (A, B) where A - all commits reachable
             from heads but not present in common, B - common (shared) elements
             that are directly reachable from heads
         """
         bases = set()
         commits = set()
         queue = []
         queue.extend(heads)
         while queue:
             e = queue.pop(0)
             if e in common:
                 bases.add(e)
             elif e not in commits:
                 commits.add(e)
                 if e in shallow:
                     continue
                 cmt = self[e]
                 queue.extend(get_parents(cmt))
         return (commits, bases)
 
     def close(self):
         """Close any files opened by this object store."""
         # Default implementation is a NO-OP
 
 
 class PackBasedObjectStore(BaseObjectStore):
 
     def __init__(self, pack_compression_level=-1):
         self._pack_cache = {}
         self.pack_compression_level = pack_compression_level
 
     @property
     def alternates(self):
         return []
 
     def contains_packed(self, sha):
         """Check if a particular object is present by SHA1 and is packed.
 
         This does not check alternates.
         """
         for pack in self.packs:
             try:
                 if sha in pack:
                     return True
             except PackFileDisappeared:
                 pass
         return False
 
     def __contains__(self, sha):
         """Check if a particular object is present by SHA1.
 
         This method makes no distinction between loose and packed objects.
         """
         if self.contains_packed(sha) or self.contains_loose(sha):
             return True
         for alternate in self.alternates:
             if sha in alternate:
                 return True
         return False
 
     def _add_cached_pack(self, base_name, pack):
         """Add a newly appeared pack to the cache by path.
 
         """
         prev_pack = self._pack_cache.get(base_name)
         if prev_pack is not pack:
             self._pack_cache[base_name] = pack
             if prev_pack:
                 prev_pack.close()
 
     def _clear_cached_packs(self):
         pack_cache = self._pack_cache
         self._pack_cache = {}
         while pack_cache:
             (name, pack) = pack_cache.popitem()
             pack.close()
 
     def _iter_cached_packs(self):
         return self._pack_cache.values()
 
     def _update_pack_cache(self):
         raise NotImplementedError(self._update_pack_cache)
 
     def close(self):
         self._clear_cached_packs()
 
     @property
     def packs(self):
         """List with pack objects."""
         return (
             list(self._iter_cached_packs()) + list(self._update_pack_cache()))
 
     def _iter_alternate_objects(self):
         """Iterate over the SHAs of all the objects in alternate stores."""
         for alternate in self.alternates:
             for alternate_object in alternate:
                 yield alternate_object
 
     def _iter_loose_objects(self):
         """Iterate over the SHAs of all loose objects."""
         raise NotImplementedError(self._iter_loose_objects)
 
     def _get_loose_object(self, sha):
         raise NotImplementedError(self._get_loose_object)
 
     def _remove_loose_object(self, sha):
         raise NotImplementedError(self._remove_loose_object)
 
     def _remove_pack(self, name):
         raise NotImplementedError(self._remove_pack)
 
     def pack_loose_objects(self):
         """Pack loose objects.
 
         Returns: Number of objects packed
         """
         objects = set()
         for sha in self._iter_loose_objects():
             objects.add((self._get_loose_object(sha), None))
         self.add_objects(list(objects))
         for obj, path in objects:
             self._remove_loose_object(obj.id)
         return len(objects)
 
     def repack(self):
         """Repack the packs in this repository.
 
         Note that this implementation is fairly naive and currently keeps all
         objects in memory while it repacks.
         """
         loose_objects = set()
         for sha in self._iter_loose_objects():
             loose_objects.add(self._get_loose_object(sha))
         objects = {(obj, None) for obj in loose_objects}
         old_packs = {p.name(): p for p in self.packs}
         for name, pack in old_packs.items():
             objects.update((obj, None) for obj in pack.iterobjects())
 
         # The name of the consolidated pack might match the name of a
         # pre-existing pack. Take care not to remove the newly created
         # consolidated pack.
 
         consolidated = self.add_objects(objects)
         old_packs.pop(consolidated.name(), None)
 
         for obj in loose_objects:
             self._remove_loose_object(obj.id)
         for name, pack in old_packs.items():
             self._remove_pack(pack)
         self._update_pack_cache()
         return len(objects)
 
     def __iter__(self):
         """Iterate over the SHAs that are present in this store."""
         self._update_pack_cache()
         for pack in self._iter_cached_packs():
             try:
                 for sha in pack:
                     yield sha
             except PackFileDisappeared:
                 pass
         for sha in self._iter_loose_objects():
             yield sha
         for sha in self._iter_alternate_objects():
             yield sha
 
     def contains_loose(self, sha):
         """Check if a particular object is present by SHA1 and is loose.
 
         This does not check alternates.
         """
         return self._get_loose_object(sha) is not None
 
     def get_raw(self, name):
         """Obtain the raw fulltext for an object.
 
         Args:
           name: sha for the object.
         Returns: tuple with numeric type and object contents.
         """
         if name == ZERO_SHA:
             raise KeyError(name)
         if len(name) == 40:
             sha = hex_to_sha(name)
             hexsha = name
         elif len(name) == 20:
             sha = name
             hexsha = None
         else:
             raise AssertionError("Invalid object name %r" % (name, ))
         for pack in self._iter_cached_packs():
             try:
                 return pack.get_raw(sha)
             except (KeyError, PackFileDisappeared):
                 pass
         if hexsha is None:
             hexsha = sha_to_hex(name)
         ret = self._get_loose_object(hexsha)
         if ret is not None:
             return ret.type_num, ret.as_raw_string()
         # Maybe something else has added a pack with the object
         # in the mean time?
         for pack in self._update_pack_cache():
             try:
                 return pack.get_raw(sha)
             except KeyError:
                 pass
         for alternate in self.alternates:
             try:
                 return alternate.get_raw(hexsha)
             except KeyError:
                 pass
         raise KeyError(hexsha)
 
     def add_objects(self, objects, progress=None):
         """Add a set of objects to this object store.
 
         Args:
           objects: Iterable over (object, path) tuples, should support
             __len__.
         Returns: Pack object of the objects written.
         """
         return self.add_pack_data(
                 *pack_objects_to_data(objects),
                 progress=progress)
 
 
 class DiskObjectStore(PackBasedObjectStore):
     """Git-style object store that exists on disk."""
 
     def __init__(self, path, loose_compression_level=-1,
                  pack_compression_level=-1):
         """Open an object store.
 
         Args:
           path: Path of the object store.
           loose_compression_level: zlib compression level for loose objects
           pack_compression_level: zlib compression level for pack objects
         """
         super(DiskObjectStore, self).__init__(
             pack_compression_level=pack_compression_level)
         self.path = path
         self.pack_dir = os.path.join(self.path, PACKDIR)
         self._alternates = None
         self.loose_compression_level = loose_compression_level
         self.pack_compression_level = pack_compression_level
 
     def __repr__(self):
         return "<%s(%r)>" % (self.__class__.__name__, self.path)
 
     @classmethod
     def from_config(cls, path, config):
         try:
             default_compression_level = int(config.get(
                 (b'core', ), b'compression').decode())
         except KeyError:
             default_compression_level = -1
         try:
             loose_compression_level = int(config.get(
                 (b'core', ), b'looseCompression').decode())
         except KeyError:
             loose_compression_level = default_compression_level
         try:
             pack_compression_level = int(config.get(
                 (b'core', ), 'packCompression').decode())
         except KeyError:
             pack_compression_level = default_compression_level
         return cls(path, loose_compression_level, pack_compression_level)
 
     @property
     def alternates(self):
         if self._alternates is not None:
             return self._alternates
         self._alternates = []
         for path in self._read_alternate_paths():
             self._alternates.append(DiskObjectStore(path))
         return self._alternates
 
     def _read_alternate_paths(self):
         try:
             f = GitFile(os.path.join(self.path, INFODIR, "alternates"), 'rb')
         except FileNotFoundError:
             return
         with f:
             for line in f.readlines():
                 line = line.rstrip(b"\n")
                 if line[0] == b"#":
                     continue
                 if os.path.isabs(line):
                     yield os.fsdecode(line)
                 else:
                     yield os.fsdecode(os.path.join(self.path, line))
 
     def add_alternate_path(self, path):
         """Add an alternate path to this object store.
         """
         try:
             os.mkdir(os.path.join(self.path, INFODIR))
         except FileExistsError:
             pass
         alternates_path = os.path.join(self.path, INFODIR, "alternates")
         with GitFile(alternates_path, 'wb') as f:
             try:
                 orig_f = open(alternates_path, 'rb')
             except FileNotFoundError:
                 pass
             else:
                 with orig_f:
                     f.write(orig_f.read())
             f.write(os.fsencode(path) + b"\n")
 
         if not os.path.isabs(path):
             path = os.path.join(self.path, path)
         self.alternates.append(DiskObjectStore(path))
 
     def _update_pack_cache(self):
         """Read and iterate over new pack files and cache them."""
         try:
             pack_dir_contents = os.listdir(self.pack_dir)
         except FileNotFoundError:
             self.close()
             return []
         pack_files = set()
         for name in pack_dir_contents:
             if name.startswith("pack-") and name.endswith(".pack"):
                 # verify that idx exists first (otherwise the pack was not yet
                 # fully written)
                 idx_name = os.path.splitext(name)[0] + ".idx"
                 if idx_name in pack_dir_contents:
                     pack_name = name[:-len(".pack")]
                     pack_files.add(pack_name)
 
         # Open newly appeared pack files
         new_packs = []
         for f in pack_files:
             if f not in self._pack_cache:
                 pack = Pack(os.path.join(self.pack_dir, f))
                 new_packs.append(pack)
                 self._pack_cache[f] = pack
         # Remove disappeared pack files
         for f in set(self._pack_cache) - pack_files:
             self._pack_cache.pop(f).close()
         return new_packs
 
     def _get_shafile_path(self, sha):
         # Check from object dir
         return hex_to_filename(self.path, sha)
 
     def _iter_loose_objects(self):
         for base in os.listdir(self.path):
             if len(base) != 2:
                 continue
             for rest in os.listdir(os.path.join(self.path, base)):
-                yield os.fsencode(base+rest)
+                sha = os.fsencode(base+rest)
+                if not valid_hexsha(sha):
+                    continue
+                yield sha
 
     def _get_loose_object(self, sha):
         path = self._get_shafile_path(sha)
         try:
             return ShaFile.from_path(path)
         except FileNotFoundError:
             return None
 
     def _remove_loose_object(self, sha):
         os.remove(self._get_shafile_path(sha))
 
     def _remove_pack(self, pack):
         try:
             del self._pack_cache[os.path.basename(pack._basename)]
         except KeyError:
             pass
         pack.close()
         os.remove(pack.data.path)
         os.remove(pack.index.path)
 
     def _get_pack_basepath(self, entries):
         suffix = iter_sha1(entry[0] for entry in entries)
         # TODO: Handle self.pack_dir being bytes
         suffix = suffix.decode('ascii')
         return os.path.join(self.pack_dir, "pack-" + suffix)
 
     def _complete_thin_pack(self, f, path, copier, indexer):
         """Move a specific file containing a pack into the pack directory.
 
         Note: The file should be on the same file system as the
             packs directory.
 
         Args:
           f: Open file object for the pack.
           path: Path to the pack file.
           copier: A PackStreamCopier to use for writing pack data.
           indexer: A PackIndexer for indexing the pack.
         """
         entries = list(indexer)
 
         # Update the header with the new number of objects.
         f.seek(0)
         write_pack_header(f, len(entries) + len(indexer.ext_refs()))
 
         # Must flush before reading (http://bugs.python.org/issue3207)
         f.flush()
 
         # Rescan the rest of the pack, computing the SHA with the new header.
         new_sha = compute_file_sha(f, end_ofs=-20)
 
         # Must reposition before writing (http://bugs.python.org/issue3207)
         f.seek(0, os.SEEK_CUR)
 
         # Complete the pack.
         for ext_sha in indexer.ext_refs():
             assert len(ext_sha) == 20
             type_num, data = self.get_raw(ext_sha)
             offset = f.tell()
             crc32 = write_pack_object(
                 f, type_num, data, sha=new_sha,
                 compression_level=self.pack_compression_level)
             entries.append((ext_sha, offset, crc32))
         pack_sha = new_sha.digest()
         f.write(pack_sha)
         f.close()
 
         # Move the pack in.
         entries.sort()
         pack_base_name = self._get_pack_basepath(entries)
         target_pack = pack_base_name + '.pack'
         if sys.platform == 'win32':
             # Windows might have the target pack file lingering. Attempt
             # removal, silently passing if the target does not exist.
             try:
                 os.remove(target_pack)
             except FileNotFoundError:
                 pass
         os.rename(path, target_pack)
 
         # Write the index.
         index_file = GitFile(pack_base_name + '.idx', 'wb')
         try:
             write_pack_index_v2(index_file, entries, pack_sha)
             index_file.close()
         finally:
             index_file.abort()
 
         # Add the pack to the store and return it.
         final_pack = Pack(pack_base_name)
         final_pack.check_length_and_checksum()
         self._add_cached_pack(pack_base_name, final_pack)
         return final_pack
 
     def add_thin_pack(self, read_all, read_some):
         """Add a new thin pack to this object store.
 
         Thin packs are packs that contain deltas with parents that exist
         outside the pack. They should never be placed in the object store
         directly, and always indexed and completed as they are copied.
 
         Args:
           read_all: Read function that blocks until the number of
             requested bytes are read.
           read_some: Read function that returns at least one byte, but may
             not return the number of bytes requested.
         Returns: A Pack object pointing at the now-completed thin pack in the
             objects/pack directory.
         """
         fd, path = tempfile.mkstemp(dir=self.path, prefix='tmp_pack_')
         with os.fdopen(fd, 'w+b') as f:
             indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
             copier = PackStreamCopier(read_all, read_some, f,
                                       delta_iter=indexer)
             copier.verify()
             return self._complete_thin_pack(f, path, copier, indexer)
 
     def move_in_pack(self, path):
         """Move a specific file containing a pack into the pack directory.
 
         Note: The file should be on the same file system as the
             packs directory.
 
         Args:
           path: Path to the pack file.
         """
         with PackData(path) as p:
             entries = p.sorted_entries()
             basename = self._get_pack_basepath(entries)
             index_name = basename + ".idx"
             if not os.path.exists(index_name):
                 with GitFile(index_name, "wb") as f:
                     write_pack_index_v2(f, entries, p.get_stored_checksum())
         for pack in self.packs:
             if pack._basename == basename:
                 return pack
         target_pack = basename + '.pack'
         if sys.platform == 'win32':
             # Windows might have the target pack file lingering. Attempt
             # removal, silently passing if the target does not exist.
             try:
                 os.remove(target_pack)
             except FileNotFoundError:
                 pass
         os.rename(path, target_pack)
         final_pack = Pack(basename)
         self._add_cached_pack(basename, final_pack)
         return final_pack
 
     def add_pack(self):
         """Add a new pack to this object store.
 
         Returns: Fileobject to write to, a commit function to
             call when the pack is finished and an abort
             function.
         """
         fd, path = tempfile.mkstemp(dir=self.pack_dir, suffix=".pack")
         f = os.fdopen(fd, 'wb')
 
         def commit():
             f.flush()
             os.fsync(fd)
             f.close()
             if os.path.getsize(path) > 0:
                 return self.move_in_pack(path)
             else:
                 os.remove(path)
                 return None
 
         def abort():
             f.close()
             os.remove(path)
         return f, commit, abort
 
     def add_object(self, obj):
         """Add a single object to this object store.
 
         Args:
           obj: Object to add
         """
         path = self._get_shafile_path(obj.id)
         dir = os.path.dirname(path)
         try:
             os.mkdir(dir)
         except FileExistsError:
             pass
         if os.path.exists(path):
             return  # Already there, no need to write again
         with GitFile(path, 'wb') as f:
             f.write(obj.as_legacy_object(
                 compression_level=self.loose_compression_level))
 
     @classmethod
     def init(cls, path):
         try:
             os.mkdir(path)
         except FileExistsError:
             pass
         os.mkdir(os.path.join(path, "info"))
         os.mkdir(os.path.join(path, PACKDIR))
         return cls(path)
 
 
 class MemoryObjectStore(BaseObjectStore):
     """Object store that keeps all objects in memory."""
 
     def __init__(self):
         super(MemoryObjectStore, self).__init__()
         self._data = {}
         self.pack_compression_level = -1
 
     def _to_hexsha(self, sha):
         if len(sha) == 40:
             return sha
         elif len(sha) == 20:
             return sha_to_hex(sha)
         else:
             raise ValueError("Invalid sha %r" % (sha,))
 
     def contains_loose(self, sha):
         """Check if a particular object is present by SHA1 and is loose."""
         return self._to_hexsha(sha) in self._data
 
     def contains_packed(self, sha):
         """Check if a particular object is present by SHA1 and is packed."""
         return False
 
     def __iter__(self):
         """Iterate over the SHAs that are present in this store."""
         return iter(self._data.keys())
 
     @property
     def packs(self):
         """List with pack objects."""
         return []
 
     def get_raw(self, name):
         """Obtain the raw text for an object.
 
         Args:
           name: sha for the object.
         Returns: tuple with numeric type and object contents.
         """
         obj = self[self._to_hexsha(name)]
         return obj.type_num, obj.as_raw_string()
 
     def __getitem__(self, name):
         return self._data[self._to_hexsha(name)].copy()
 
     def __delitem__(self, name):
         """Delete an object from this store, for testing only."""
         del self._data[self._to_hexsha(name)]
 
     def add_object(self, obj):
         """Add a single object to this object store.
 
         """
         self._data[obj.id] = obj.copy()
 
     def add_objects(self, objects, progress=None):
         """Add a set of objects to this object store.
 
         Args:
           objects: Iterable over a list of (object, path) tuples
         """
         for obj, path in objects:
             self.add_object(obj)
 
     def add_pack(self):
         """Add a new pack to this object store.
 
         Because this object store doesn't support packs, we extract and add the
         individual objects.
 
         Returns: Fileobject to write to and a commit function to
             call when the pack is finished.
         """
         f = BytesIO()
 
         def commit():
             p = PackData.from_file(BytesIO(f.getvalue()), f.tell())
             f.close()
             for obj in PackInflater.for_pack_data(p, self.get_raw):
                 self.add_object(obj)
 
         def abort():
             pass
         return f, commit, abort
 
     def _complete_thin_pack(self, f, indexer):
         """Complete a thin pack by adding external references.
 
         Args:
           f: Open file object for the pack.
           indexer: A PackIndexer for indexing the pack.
         """
         entries = list(indexer)
 
         # Update the header with the new number of objects.
         f.seek(0)
         write_pack_header(f, len(entries) + len(indexer.ext_refs()))
 
         # Rescan the rest of the pack, computing the SHA with the new header.
         new_sha = compute_file_sha(f, end_ofs=-20)
 
         # Complete the pack.
         for ext_sha in indexer.ext_refs():
             assert len(ext_sha) == 20
             type_num, data = self.get_raw(ext_sha)
             write_pack_object(
                 f, type_num, data, sha=new_sha)
         pack_sha = new_sha.digest()
         f.write(pack_sha)
 
     def add_thin_pack(self, read_all, read_some):
         """Add a new thin pack to this object store.
 
         Thin packs are packs that contain deltas with parents that exist
         outside the pack. Because this object store doesn't support packs, we
         extract and add the individual objects.
 
         Args:
           read_all: Read function that blocks until the number of
             requested bytes are read.
           read_some: Read function that returns at least one byte, but may
             not return the number of bytes requested.
         """
         f, commit, abort = self.add_pack()
         try:
             indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
             copier = PackStreamCopier(read_all, read_some, f,
                                       delta_iter=indexer)
             copier.verify()
             self._complete_thin_pack(f, indexer)
         except BaseException:
             abort()
             raise
         else:
             commit()
 
 
 class ObjectIterator(object):
     """Interface for iterating over objects."""
 
     def iterobjects(self):
         raise NotImplementedError(self.iterobjects)
 
 
 class ObjectStoreIterator(ObjectIterator):
     """ObjectIterator that works on top of an ObjectStore."""
 
     def __init__(self, store, sha_iter):
         """Create a new ObjectIterator.
 
         Args:
           store: Object store to retrieve from
           sha_iter: Iterator over (sha, path) tuples
         """
         self.store = store
         self.sha_iter = sha_iter
         self._shas = []
 
     def __iter__(self):
         """Yield tuple with next object and path."""
         for sha, path in self.itershas():
             yield self.store[sha], path
 
     def iterobjects(self):
         """Iterate over just the objects."""
         for o, path in self:
             yield o
 
     def itershas(self):
         """Iterate over the SHAs."""
         for sha in self._shas:
             yield sha
         for sha in self.sha_iter:
             self._shas.append(sha)
             yield sha
 
     def __contains__(self, needle):
         """Check if an object is present.
 
         Note: This checks if the object is present in
             the underlying object store, not if it would
             be yielded by the iterator.
 
         Args:
           needle: SHA1 of the object to check for
         """
         if needle == ZERO_SHA:
             return False
         return needle in self.store
 
     def __getitem__(self, key):
         """Find an object by SHA1.
 
         Note: This retrieves the object from the underlying
             object store. It will also succeed if the object would
             not be returned by the iterator.
         """
         return self.store[key]
 
     def __len__(self):
         """Return the number of objects."""
         return len(list(self.itershas()))
 
     def empty(self):
         import warnings
         warnings.warn('Use bool() instead.', DeprecationWarning)
         return self._empty()
 
     def _empty(self):
         it = self.itershas()
         try:
             next(it)
         except StopIteration:
             return True
         else:
             return False
 
     def __bool__(self):
         """Indicate whether this object has contents."""
         return not self._empty()
 
 
 def tree_lookup_path(lookup_obj, root_sha, path):
     """Look up an object in a Git tree.
 
     Args:
       lookup_obj: Callback for retrieving object by SHA1
       root_sha: SHA1 of the root tree
       path: Path to lookup
     Returns: A tuple of (mode, SHA) of the resulting path.
     """
     tree = lookup_obj(root_sha)
     if not isinstance(tree, Tree):
         raise NotTreeError(root_sha)
     return tree.lookup_path(lookup_obj, path)
 
 
 def _collect_filetree_revs(obj_store, tree_sha, kset):
     """Collect SHA1s of files and directories for specified tree.
 
     Args:
       obj_store: Object store to get objects by SHA from
       tree_sha: tree reference to walk
       kset: set to fill with references to files and directories
     """
     filetree = obj_store[tree_sha]
     for name, mode, sha in filetree.iteritems():
         if not S_ISGITLINK(mode) and sha not in kset:
             kset.add(sha)
             if stat.S_ISDIR(mode):
                 _collect_filetree_revs(obj_store, sha, kset)
 
 
 def _split_commits_and_tags(obj_store, lst, ignore_unknown=False):
     """Split object id list into three lists with commit, tag, and other SHAs.
 
     Commits referenced by tags are included into commits
     list as well. Only SHA1s known in this repository will get
     through, and unless ignore_unknown argument is True, KeyError
     is thrown for SHA1 missing in the repository
 
     Args:
       obj_store: Object store to get objects by SHA1 from
       lst: Collection of commit and tag SHAs
       ignore_unknown: True to skip SHA1 missing in the repository
         silently.
     Returns: A tuple of (commits, tags, others) SHA1s
     """
     commits = set()
     tags = set()
     others = set()
     for e in lst:
         try:
             o = obj_store[e]
         except KeyError:
             if not ignore_unknown:
                 raise
         else:
             if isinstance(o, Commit):
                 commits.add(e)
             elif isinstance(o, Tag):
                 tags.add(e)
                 tagged = o.object[1]
                 c, t, o = _split_commits_and_tags(
                     obj_store, [tagged], ignore_unknown=ignore_unknown)
                 commits |= c
                 tags |= t
                 others |= o
             else:
                 others.add(e)
     return (commits, tags, others)
 
 
 class MissingObjectFinder(object):
     """Find the objects missing from another object store.
 
     Args:
       object_store: Object store containing at least all objects to be
         sent
       haves: SHA1s of commits not to send (already present in target)
       wants: SHA1s of commits to send
       progress: Optional function to report progress to.
       get_tagged: Function that returns a dict of pointed-to sha -> tag
         sha for including tags.
       get_parents: Optional function for getting the parents of a commit.
       tagged: dict of pointed-to sha -> tag sha for including tags
     """
 
     def __init__(self, object_store, haves, wants, shallow=None, progress=None,
                  get_tagged=None, get_parents=lambda commit: commit.parents):
         self.object_store = object_store
         if shallow is None:
             shallow = set()
         self._get_parents = get_parents
         # process Commits and Tags differently
         # Note, while haves may list commits/tags not available locally,
         # and such SHAs would get filtered out by _split_commits_and_tags,
         # wants shall list only known SHAs, and otherwise
         # _split_commits_and_tags fails with KeyError
         have_commits, have_tags, have_others = (
             _split_commits_and_tags(object_store, haves, True))
         want_commits, want_tags, want_others = (
             _split_commits_and_tags(object_store, wants, False))
         # all_ancestors is a set of commits that shall not be sent
         # (complete repository up to 'haves')
         all_ancestors = object_store._collect_ancestors(
             have_commits, shallow=shallow, get_parents=self._get_parents)[0]
         # all_missing - complete set of commits between haves and wants
         # common - commits from all_ancestors we hit into while
         # traversing parent hierarchy of wants
         missing_commits, common_commits = object_store._collect_ancestors(
             want_commits, all_ancestors, shallow=shallow,
             get_parents=self._get_parents)
         self.sha_done = set()
         # Now, fill sha_done with commits and revisions of
         # files and directories known to be both locally
         # and on target. Thus these commits and files
         # won't get selected for fetch
         for h in common_commits:
             self.sha_done.add(h)
             cmt = object_store[h]
             _collect_filetree_revs(object_store, cmt.tree, self.sha_done)
         # record tags we have as visited, too
         for t in have_tags:
             self.sha_done.add(t)
 
         missing_tags = want_tags.difference(have_tags)
         missing_others = want_others.difference(have_others)
         # in fact, what we 'want' is commits, tags, and others
         # we've found missing
         wants = missing_commits.union(missing_tags)
         wants = wants.union(missing_others)
 
         self.objects_to_send = set([(w, None, False) for w in wants])
 
         if progress is None:
             self.progress = lambda x: None
         else:
             self.progress = progress
         self._tagged = get_tagged and get_tagged() or {}
 
     def add_todo(self, entries):
         self.objects_to_send.update([e for e in entries
                                      if not e[0] in self.sha_done])
 
     def next(self):
         while True:
             if not self.objects_to_send:
                 return None
             (sha, name, leaf) = self.objects_to_send.pop()
             if sha not in self.sha_done:
                 break
         if not leaf:
             o = self.object_store[sha]
             if isinstance(o, Commit):
                 self.add_todo([(o.tree, "", False)])
             elif isinstance(o, Tree):
                 self.add_todo([(s, n, not stat.S_ISDIR(m))
                                for n, m, s in o.iteritems()
                                if not S_ISGITLINK(m)])
             elif isinstance(o, Tag):
                 self.add_todo([(o.object[1], None, False)])
         if sha in self._tagged:
             self.add_todo([(self._tagged[sha], None, True)])
         self.sha_done.add(sha)
         self.progress(("counting objects: %d\r" %
                        len(self.sha_done)).encode('ascii'))
         return (sha, name)
 
     __next__ = next
 
 
 class ObjectStoreGraphWalker(object):
     """Graph walker that finds what commits are missing from an object store.
 
     :ivar heads: Revisions without descendants in the local repo
     :ivar get_parents: Function to retrieve parents in the local repo
     """
 
     def __init__(self, local_heads, get_parents, shallow=None):
         """Create a new instance.
 
         Args:
           local_heads: Heads to start search with
           get_parents: Function for finding the parents of a SHA1.
         """
         self.heads = set(local_heads)
         self.get_parents = get_parents
         self.parents = {}
         if shallow is None:
             shallow = set()
         self.shallow = shallow
 
     def ack(self, sha):
         """Ack that a revision and its ancestors are present in the source."""
         if len(sha) != 40:
             raise ValueError("unexpected sha %r received" % sha)
         ancestors = set([sha])
 
         # stop if we run out of heads to remove
         while self.heads:
             for a in ancestors:
                 if a in self.heads:
                     self.heads.remove(a)
 
             # collect all ancestors
             new_ancestors = set()
             for a in ancestors:
                 ps = self.parents.get(a)
                 if ps is not None:
                     new_ancestors.update(ps)
                 self.parents[a] = None
 
             # no more ancestors; stop
             if not new_ancestors:
                 break
 
             ancestors = new_ancestors
 
     def next(self):
         """Iterate over ancestors of heads in the target."""
         if self.heads:
             ret = self.heads.pop()
             ps = self.get_parents(ret)
             self.parents[ret] = ps
             self.heads.update(
                 [p for p in ps if p not in self.parents])
             return ret
         return None
 
     __next__ = next
 
 
 def commit_tree_changes(object_store, tree, changes):
     """Commit a specified set of changes to a tree structure.
 
     This will apply a set of changes on top of an existing tree, storing new
     objects in object_store.
 
     changes are a list of tuples with (path, mode, object_sha).
     Paths can be both blobs and trees. See the mode and
     object sha to None deletes the path.
 
     This method works especially well if there are only a small
     number of changes to a big tree. For a large number of changes
     to a large tree, use e.g. commit_tree.
 
     Args:
       object_store: Object store to store new objects in
         and retrieve old ones from.
       tree: Original tree root
       changes: changes to apply
     Returns: New tree root object
     """
     # TODO(jelmer): Save up the objects and add them using .add_objects
     # rather than with individual calls to .add_object.
     nested_changes = {}
     for (path, new_mode, new_sha) in changes:
         try:
             (dirname, subpath) = path.split(b'/', 1)
         except ValueError:
             if new_sha is None:
                 del tree[path]
             else:
                 tree[path] = (new_mode, new_sha)
         else:
             nested_changes.setdefault(dirname, []).append(
                 (subpath, new_mode, new_sha))
     for name, subchanges in nested_changes.items():
         try:
             orig_subtree = object_store[tree[name][1]]
         except KeyError:
             orig_subtree = Tree()
         subtree = commit_tree_changes(object_store, orig_subtree, subchanges)
         if len(subtree) == 0:
             del tree[name]
         else:
             tree[name] = (stat.S_IFDIR, subtree.id)
     object_store.add_object(tree)
     return tree
 
 
 class OverlayObjectStore(BaseObjectStore):
     """Object store that can overlay multiple object stores."""
 
     def __init__(self, bases, add_store=None):
         self.bases = bases
         self.add_store = add_store
 
     def add_object(self, object):
         if self.add_store is None:
             raise NotImplementedError(self.add_object)
         return self.add_store.add_object(object)
 
     def add_objects(self, objects, progress=None):
         if self.add_store is None:
             raise NotImplementedError(self.add_object)
         return self.add_store.add_objects(objects, progress)
 
     @property
     def packs(self):
         ret = []
         for b in self.bases:
             ret.extend(b.packs)
         return ret
 
     def __iter__(self):
         done = set()
         for b in self.bases:
             for o_id in b:
                 if o_id not in done:
                     yield o_id
                     done.add(o_id)
 
     def get_raw(self, sha_id):
         for b in self.bases:
             try:
                 return b.get_raw(sha_id)
             except KeyError:
                 pass
         raise KeyError(sha_id)
 
     def contains_packed(self, sha):
         for b in self.bases:
             if b.contains_packed(sha):
                 return True
         return False
 
     def contains_loose(self, sha):
         for b in self.bases:
             if b.contains_loose(sha):
                 return True
         return False
 
 
 def read_packs_file(f):
     """Yield the packs listed in a packs file."""
     for line in f.read().splitlines():
         if not line:
             continue
         (kind, name) = line.split(b" ", 1)
         if kind != b"P":
             continue
         yield os.fsdecode(name)
diff --git a/dulwich/tests/test_object_store.py b/dulwich/tests/test_object_store.py
index 5aeb837e..17be2465 100644
--- a/dulwich/tests/test_object_store.py
+++ b/dulwich/tests/test_object_store.py
@@ -1,663 +1,679 @@
 # test_object_store.py -- tests for object_store.py
 # Copyright (C) 2008 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Tests for the object store interface."""
 
 
 from contextlib import closing
 from io import BytesIO
 import os
 import shutil
 import stat
 import tempfile
 
 from dulwich.index import (
     commit_tree,
     )
 from dulwich.errors import (
     NotTreeError,
     )
 from dulwich.objects import (
     sha_to_hex,
     Blob,
     Tree,
     TreeEntry,
     EmptyFileException,
     )
 from dulwich.object_store import (
     DiskObjectStore,
     MemoryObjectStore,
     OverlayObjectStore,
     ObjectStoreGraphWalker,
     commit_tree_changes,
     read_packs_file,
     tree_lookup_path,
     )
 from dulwich.pack import (
     REF_DELTA,
     write_pack_objects,
     )
 from dulwich.tests import (
     TestCase,
     )
 from dulwich.tests.utils import (
     make_object,
     make_tag,
     build_pack,
     )
 
 
 testobject = make_object(Blob, data=b"yummy data")
 
 
 class ObjectStoreTests(object):
 
     def test_determine_wants_all(self):
         self.assertEqual(
             [b"1" * 40],
             self.store.determine_wants_all({b"refs/heads/foo": b"1" * 40}))
 
     def test_determine_wants_all_zero(self):
         self.assertEqual(
             [], self.store.determine_wants_all({b"refs/heads/foo": b"0" * 40}))
 
     def test_iter(self):
         self.assertEqual([], list(self.store))
 
     def test_get_nonexistant(self):
         self.assertRaises(KeyError, lambda: self.store[b"a" * 40])
 
     def test_contains_nonexistant(self):
         self.assertFalse((b"a" * 40) in self.store)
 
     def test_add_objects_empty(self):
         self.store.add_objects([])
 
     def test_add_commit(self):
         # TODO: Argh, no way to construct Git commit objects without
         # access to a serialized form.
         self.store.add_objects([])
 
     def test_store_resilience(self):
         """Test if updating an existing stored object doesn't erase the
         object from the store.
         """
         test_object = make_object(Blob, data=b'data')
 
         self.store.add_object(test_object)
         test_object_id = test_object.id
         test_object.data = test_object.data + b'update'
         stored_test_object = self.store[test_object_id]
 
         self.assertNotEqual(test_object.id, stored_test_object.id)
         self.assertEqual(stored_test_object.id, test_object_id)
 
     def test_add_object(self):
         self.store.add_object(testobject)
         self.assertEqual(set([testobject.id]), set(self.store))
         self.assertTrue(testobject.id in self.store)
         r = self.store[testobject.id]
         self.assertEqual(r, testobject)
 
     def test_add_objects(self):
         data = [(testobject, "mypath")]
         self.store.add_objects(data)
         self.assertEqual(set([testobject.id]), set(self.store))
         self.assertTrue(testobject.id in self.store)
         r = self.store[testobject.id]
         self.assertEqual(r, testobject)
 
     def test_tree_changes(self):
         blob_a1 = make_object(Blob, data=b'a1')
         blob_a2 = make_object(Blob, data=b'a2')
         blob_b = make_object(Blob, data=b'b')
         for blob in [blob_a1, blob_a2, blob_b]:
             self.store.add_object(blob)
 
         blobs_1 = [(b'a', blob_a1.id, 0o100644), (b'b', blob_b.id, 0o100644)]
         tree1_id = commit_tree(self.store, blobs_1)
         blobs_2 = [(b'a', blob_a2.id, 0o100644), (b'b', blob_b.id, 0o100644)]
         tree2_id = commit_tree(self.store, blobs_2)
         change_a = ((b'a', b'a'), (0o100644, 0o100644),
                     (blob_a1.id, blob_a2.id))
         self.assertEqual([change_a],
                          list(self.store.tree_changes(tree1_id, tree2_id)))
         self.assertEqual(
             [change_a, ((b'b', b'b'), (0o100644, 0o100644),
              (blob_b.id, blob_b.id))],
             list(self.store.tree_changes(tree1_id, tree2_id,
                  want_unchanged=True)))
 
     def test_iter_tree_contents(self):
         blob_a = make_object(Blob, data=b'a')
         blob_b = make_object(Blob, data=b'b')
         blob_c = make_object(Blob, data=b'c')
         for blob in [blob_a, blob_b, blob_c]:
             self.store.add_object(blob)
 
         blobs = [
             (b'a', blob_a.id, 0o100644),
             (b'ad/b', blob_b.id, 0o100644),
             (b'ad/bd/c', blob_c.id, 0o100755),
             (b'ad/c', blob_c.id, 0o100644),
             (b'c', blob_c.id, 0o100644),
         ]
         tree_id = commit_tree(self.store, blobs)
         self.assertEqual([TreeEntry(p, m, h) for (p, h, m) in blobs],
                          list(self.store.iter_tree_contents(tree_id)))
 
     def test_iter_tree_contents_include_trees(self):
         blob_a = make_object(Blob, data=b'a')
         blob_b = make_object(Blob, data=b'b')
         blob_c = make_object(Blob, data=b'c')
         for blob in [blob_a, blob_b, blob_c]:
             self.store.add_object(blob)
 
         blobs = [
           (b'a', blob_a.id, 0o100644),
           (b'ad/b', blob_b.id, 0o100644),
           (b'ad/bd/c', blob_c.id, 0o100755),
           ]
         tree_id = commit_tree(self.store, blobs)
         tree = self.store[tree_id]
         tree_ad = self.store[tree[b'ad'][1]]
         tree_bd = self.store[tree_ad[b'bd'][1]]
 
         expected = [
           TreeEntry(b'', 0o040000, tree_id),
           TreeEntry(b'a', 0o100644, blob_a.id),
           TreeEntry(b'ad', 0o040000, tree_ad.id),
           TreeEntry(b'ad/b', 0o100644, blob_b.id),
           TreeEntry(b'ad/bd', 0o040000, tree_bd.id),
           TreeEntry(b'ad/bd/c', 0o100755, blob_c.id),
           ]
         actual = self.store.iter_tree_contents(tree_id, include_trees=True)
         self.assertEqual(expected, list(actual))
 
     def make_tag(self, name, obj):
         tag = make_tag(obj, name=name)
         self.store.add_object(tag)
         return tag
 
     def test_peel_sha(self):
         self.store.add_object(testobject)
         tag1 = self.make_tag(b'1', testobject)
         tag2 = self.make_tag(b'2', testobject)
         tag3 = self.make_tag(b'3', testobject)
         for obj in [testobject, tag1, tag2, tag3]:
             self.assertEqual(testobject, self.store.peel_sha(obj.id))
 
     def test_get_raw(self):
         self.store.add_object(testobject)
         self.assertEqual((Blob.type_num, b'yummy data'),
                          self.store.get_raw(testobject.id))
 
     def test_close(self):
         # For now, just check that close doesn't barf.
         self.store.add_object(testobject)
         self.store.close()
 
 
 class OverlayObjectStoreTests(ObjectStoreTests, TestCase):
 
     def setUp(self):
         TestCase.setUp(self)
         self.bases = [MemoryObjectStore(), MemoryObjectStore()]
         self.store = OverlayObjectStore(self.bases, self.bases[0])
 
 
 class MemoryObjectStoreTests(ObjectStoreTests, TestCase):
 
     def setUp(self):
         TestCase.setUp(self)
         self.store = MemoryObjectStore()
 
     def test_add_pack(self):
         o = MemoryObjectStore()
         f, commit, abort = o.add_pack()
         try:
             b = make_object(Blob, data=b"more yummy data")
             write_pack_objects(f, [(b, None)])
         except BaseException:
             abort()
             raise
         else:
             commit()
 
     def test_add_pack_emtpy(self):
         o = MemoryObjectStore()
         f, commit, abort = o.add_pack()
         commit()
 
     def test_add_thin_pack(self):
         o = MemoryObjectStore()
         blob = make_object(Blob, data=b'yummy data')
         o.add_object(blob)
 
         f = BytesIO()
         entries = build_pack(f, [
             (REF_DELTA, (blob.id, b'more yummy data')),
             ], store=o)
         o.add_thin_pack(f.read, None)
         packed_blob_sha = sha_to_hex(entries[0][3])
         self.assertEqual((Blob.type_num, b'more yummy data'),
                          o.get_raw(packed_blob_sha))
 
     def test_add_thin_pack_empty(self):
         o = MemoryObjectStore()
 
         f = BytesIO()
         entries = build_pack(f, [], store=o)
         self.assertEqual([], entries)
         o.add_thin_pack(f.read, None)
 
 
 class PackBasedObjectStoreTests(ObjectStoreTests):
 
     def tearDown(self):
         for pack in self.store.packs:
             pack.close()
 
     def test_empty_packs(self):
         self.assertEqual([], list(self.store.packs))
 
     def test_pack_loose_objects(self):
         b1 = make_object(Blob, data=b"yummy data")
         self.store.add_object(b1)
         b2 = make_object(Blob, data=b"more yummy data")
         self.store.add_object(b2)
         b3 = make_object(Blob, data=b"even more yummy data")
         b4 = make_object(Blob, data=b"and more yummy data")
         self.store.add_objects([(b3, None), (b4, None)])
         self.assertEqual({b1.id, b2.id, b3.id, b4.id}, set(self.store))
         self.assertEqual(1, len(self.store.packs))
         self.assertEqual(2, self.store.pack_loose_objects())
         self.assertNotEqual([], list(self.store.packs))
         self.assertEqual(0, self.store.pack_loose_objects())
 
     def test_repack(self):
         b1 = make_object(Blob, data=b"yummy data")
         self.store.add_object(b1)
         b2 = make_object(Blob, data=b"more yummy data")
         self.store.add_object(b2)
         b3 = make_object(Blob, data=b"even more yummy data")
         b4 = make_object(Blob, data=b"and more yummy data")
         self.store.add_objects([(b3, None), (b4, None)])
         b5 = make_object(Blob, data=b"and more data")
         b6 = make_object(Blob, data=b"and some more data")
         self.store.add_objects([(b5, None), (b6, None)])
         self.assertEqual({b1.id, b2.id, b3.id, b4.id, b5.id, b6.id},
                          set(self.store))
         self.assertEqual(2, len(self.store.packs))
         self.assertEqual(6, self.store.repack())
         self.assertEqual(1, len(self.store.packs))
         self.assertEqual(0, self.store.pack_loose_objects())
 
     def test_repack_existing(self):
         b1 = make_object(Blob, data=b"yummy data")
         self.store.add_object(b1)
         b2 = make_object(Blob, data=b"more yummy data")
         self.store.add_object(b2)
         self.store.add_objects([(b1, None), (b2, None)])
         self.store.add_objects([(b2, None)])
         self.assertEqual({b1.id, b2.id}, set(self.store))
         self.assertEqual(2, len(self.store.packs))
         self.assertEqual(2, self.store.repack())
         self.assertEqual(1, len(self.store.packs))
         self.assertEqual(0, self.store.pack_loose_objects())
 
         self.assertEqual({b1.id, b2.id}, set(self.store))
         self.assertEqual(1, len(self.store.packs))
         self.assertEqual(2, self.store.repack())
         self.assertEqual(1, len(self.store.packs))
         self.assertEqual(0, self.store.pack_loose_objects())
 
 
 class DiskObjectStoreTests(PackBasedObjectStoreTests, TestCase):
 
     def setUp(self):
         TestCase.setUp(self)
         self.store_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, self.store_dir)
         self.store = DiskObjectStore.init(self.store_dir)
 
     def tearDown(self):
         TestCase.tearDown(self)
         PackBasedObjectStoreTests.tearDown(self)
 
     def test_loose_compression_level(self):
         alternate_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, alternate_dir)
         alternate_store = DiskObjectStore(
             alternate_dir, loose_compression_level=6)
         b2 = make_object(Blob, data=b"yummy data")
         alternate_store.add_object(b2)
 
     def test_alternates(self):
         alternate_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, alternate_dir)
         alternate_store = DiskObjectStore(alternate_dir)
         b2 = make_object(Blob, data=b"yummy data")
         alternate_store.add_object(b2)
         store = DiskObjectStore(self.store_dir)
         self.assertRaises(KeyError, store.__getitem__, b2.id)
         store.add_alternate_path(alternate_dir)
         self.assertIn(b2.id, store)
         self.assertEqual(b2, store[b2.id])
 
     def test_corrupted_object_raise_exception(self):
         """Corrupted sha1 disk file should raise specific exception"""
         self.store.add_object(testobject)
         self.assertEqual((Blob.type_num, b'yummy data'),
                          self.store.get_raw(testobject.id))
         self.assertTrue(self.store.contains_loose(testobject.id))
         self.assertIsNotNone(self.store._get_loose_object(testobject.id))
 
         path = self.store._get_shafile_path(testobject.id)
         with open(path, 'wb') as f:  # corrupt the file
             f.write(b'')
 
         expected_error_msg = 'Corrupted empty file detected'
         try:
             self.store.contains_loose(testobject.id)
         except EmptyFileException as e:
             self.assertEqual(str(e), expected_error_msg)
 
         try:
             self.store._get_loose_object(testobject.id)
         except EmptyFileException as e:
             self.assertEqual(str(e), expected_error_msg)
 
         # this does not change iteration on loose objects though
         self.assertEqual([testobject.id],
                          list(self.store._iter_loose_objects()))
 
+    def test_tempfile_in_loose_store(self):
+        self.store.add_object(testobject)
+        self.assertEqual([testobject.id],
+                         list(self.store._iter_loose_objects()))
+
+        # add temporary files to the loose store
+        for i in range(256):
+            dirname = os.path.join(self.store_dir, "%02x" % i)
+            if not os.path.isdir(dirname):
+                os.makedirs(dirname)
+            fd, n = tempfile.mkstemp(prefix="tmp_obj_", dir=dirname)
+            os.close(fd)
+
+        self.assertEqual([testobject.id],
+                         list(self.store._iter_loose_objects()))
+
     def test_add_alternate_path(self):
         store = DiskObjectStore(self.store_dir)
         self.assertEqual([], list(store._read_alternate_paths()))
         store.add_alternate_path("/foo/path")
         self.assertEqual(["/foo/path"], list(store._read_alternate_paths()))
         store.add_alternate_path("/bar/path")
         self.assertEqual(
             ["/foo/path", "/bar/path"],
             list(store._read_alternate_paths()))
 
     def test_rel_alternative_path(self):
         alternate_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, alternate_dir)
         alternate_store = DiskObjectStore(alternate_dir)
         b2 = make_object(Blob, data=b"yummy data")
         alternate_store.add_object(b2)
         store = DiskObjectStore(self.store_dir)
         self.assertRaises(KeyError, store.__getitem__, b2.id)
         store.add_alternate_path(
             os.path.relpath(alternate_dir, self.store_dir))
         self.assertEqual(list(alternate_store), list(store.alternates[0]))
         self.assertIn(b2.id, store)
         self.assertEqual(b2, store[b2.id])
 
     def test_pack_dir(self):
         o = DiskObjectStore(self.store_dir)
         self.assertEqual(os.path.join(self.store_dir, "pack"), o.pack_dir)
 
     def test_add_pack(self):
         o = DiskObjectStore(self.store_dir)
         f, commit, abort = o.add_pack()
         try:
             b = make_object(Blob, data=b"more yummy data")
             write_pack_objects(f, [(b, None)])
         except BaseException:
             abort()
             raise
         else:
             commit()
 
     def test_add_thin_pack(self):
         o = DiskObjectStore(self.store_dir)
         try:
             blob = make_object(Blob, data=b'yummy data')
             o.add_object(blob)
 
             f = BytesIO()
             entries = build_pack(f, [
               (REF_DELTA, (blob.id, b'more yummy data')),
               ], store=o)
 
             with o.add_thin_pack(f.read, None) as pack:
                 packed_blob_sha = sha_to_hex(entries[0][3])
                 pack.check_length_and_checksum()
                 self.assertEqual(
                     sorted([blob.id, packed_blob_sha]), list(pack))
                 self.assertTrue(o.contains_packed(packed_blob_sha))
                 self.assertTrue(o.contains_packed(blob.id))
                 self.assertEqual((Blob.type_num, b'more yummy data'),
                                  o.get_raw(packed_blob_sha))
         finally:
             o.close()
 
     def test_add_thin_pack_empty(self):
         with closing(DiskObjectStore(self.store_dir)) as o:
             f = BytesIO()
             entries = build_pack(f, [], store=o)
             self.assertEqual([], entries)
             o.add_thin_pack(f.read, None)
 
 
 class TreeLookupPathTests(TestCase):
 
     def setUp(self):
         TestCase.setUp(self)
         self.store = MemoryObjectStore()
         blob_a = make_object(Blob, data=b'a')
         blob_b = make_object(Blob, data=b'b')
         blob_c = make_object(Blob, data=b'c')
         for blob in [blob_a, blob_b, blob_c]:
             self.store.add_object(blob)
 
         blobs = [
           (b'a', blob_a.id, 0o100644),
           (b'ad/b', blob_b.id, 0o100644),
           (b'ad/bd/c', blob_c.id, 0o100755),
           (b'ad/c', blob_c.id, 0o100644),
           (b'c', blob_c.id, 0o100644),
           ]
         self.tree_id = commit_tree(self.store, blobs)
 
     def get_object(self, sha):
         return self.store[sha]
 
     def test_lookup_blob(self):
         o_id = tree_lookup_path(self.get_object, self.tree_id, b'a')[1]
         self.assertTrue(isinstance(self.store[o_id], Blob))
 
     def test_lookup_tree(self):
         o_id = tree_lookup_path(self.get_object, self.tree_id, b'ad')[1]
         self.assertTrue(isinstance(self.store[o_id], Tree))
         o_id = tree_lookup_path(self.get_object, self.tree_id, b'ad/bd')[1]
         self.assertTrue(isinstance(self.store[o_id], Tree))
         o_id = tree_lookup_path(self.get_object, self.tree_id, b'ad/bd/')[1]
         self.assertTrue(isinstance(self.store[o_id], Tree))
 
     def test_lookup_nonexistent(self):
         self.assertRaises(
             KeyError, tree_lookup_path, self.get_object, self.tree_id, b'j')
 
     def test_lookup_not_tree(self):
         self.assertRaises(
             NotTreeError, tree_lookup_path, self.get_object, self.tree_id,
             b'ad/b/j')
 
 
 class ObjectStoreGraphWalkerTests(TestCase):
 
     def get_walker(self, heads, parent_map):
         new_parent_map = dict(
                 [(k * 40, [(p * 40) for p in ps])
                  for (k, ps) in parent_map.items()])
         return ObjectStoreGraphWalker([x * 40 for x in heads],
                                       new_parent_map.__getitem__)
 
     def test_ack_invalid_value(self):
         gw = self.get_walker([], {})
         self.assertRaises(ValueError, gw.ack, "tooshort")
 
     def test_empty(self):
         gw = self.get_walker([], {})
         self.assertIs(None, next(gw))
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_descends(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
         self.assertEqual(b"a" * 40, next(gw))
         self.assertEqual(b"b" * 40, next(gw))
 
     def test_present(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_parent_present(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
         self.assertEqual(b"a" * 40, next(gw))
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_child_ack_later(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": [b"c"], b"c": []})
         self.assertEqual(b"a" * 40, next(gw))
         self.assertEqual(b"b" * 40, next(gw))
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_only_once(self):
         # a  b
         # |  |
         # c  d
         # \ /
         #  e
         gw = self.get_walker([b"a", b"b"], {
                 b"a": [b"c"],
                 b"b": [b"d"],
                 b"c": [b"e"],
                 b"d": [b"e"],
                 b"e": [],
                 })
         walk = []
         acked = False
         walk.append(next(gw))
         walk.append(next(gw))
         # A branch (a, c) or (b, d) may be done after 2 steps or 3 depending on
         # the order walked: 3-step walks include (a, b, c) and (b, a, d), etc.
         if walk == [b"a" * 40, b"c" * 40] or walk == [b"b" * 40, b"d" * 40]:
             gw.ack(walk[0])
             acked = True
 
         walk.append(next(gw))
         if not acked and walk[2] == b"c" * 40:
             gw.ack(b"a" * 40)
         elif not acked and walk[2] == b"d" * 40:
             gw.ack(b"b" * 40)
         walk.append(next(gw))
         self.assertIs(None, next(gw))
 
         self.assertEqual([b"a" * 40, b"b" * 40, b"c" * 40, b"d" * 40],
                          sorted(walk))
         self.assertLess(walk.index(b"a" * 40), walk.index(b"c" * 40))
         self.assertLess(walk.index(b"b" * 40), walk.index(b"d" * 40))
 
 
 class CommitTreeChangesTests(TestCase):
 
     def setUp(self):
         super(CommitTreeChangesTests, self).setUp()
         self.store = MemoryObjectStore()
         self.blob_a = make_object(Blob, data=b'a')
         self.blob_b = make_object(Blob, data=b'b')
         self.blob_c = make_object(Blob, data=b'c')
         for blob in [self.blob_a, self.blob_b, self.blob_c]:
             self.store.add_object(blob)
 
         blobs = [
           (b'a', self.blob_a.id, 0o100644),
           (b'ad/b', self.blob_b.id, 0o100644),
           (b'ad/bd/c', self.blob_c.id, 0o100755),
           (b'ad/c', self.blob_c.id, 0o100644),
           (b'c', self.blob_c.id, 0o100644),
           ]
         self.tree_id = commit_tree(self.store, blobs)
 
     def test_no_changes(self):
         self.assertEqual(
                 self.store[self.tree_id],
                 commit_tree_changes(self.store, self.store[self.tree_id], []))
 
     def test_add_blob(self):
         blob_d = make_object(Blob, data=b'd')
         new_tree = commit_tree_changes(
                 self.store, self.store[self.tree_id], [
                     (b'd', 0o100644, blob_d.id)])
         self.assertEqual(
             new_tree[b'd'],
             (33188, b'c59d9b6344f1af00e504ba698129f07a34bbed8d'))
 
     def test_add_blob_in_dir(self):
         blob_d = make_object(Blob, data=b'd')
         new_tree = commit_tree_changes(
                 self.store, self.store[self.tree_id], [
                     (b'e/f/d', 0o100644, blob_d.id)])
         self.assertEqual(
             new_tree.items(), [
                 TreeEntry(path=b'a', mode=stat.S_IFREG | 0o100644,
                           sha=self.blob_a.id),
                 TreeEntry(path=b'ad', mode=stat.S_IFDIR,
                           sha=b'0e2ce2cd7725ff4817791be31ccd6e627e801f4a'),
                 TreeEntry(path=b'c', mode=stat.S_IFREG | 0o100644,
                           sha=self.blob_c.id),
                 TreeEntry(path=b'e', mode=stat.S_IFDIR,
                           sha=b'6ab344e288724ac2fb38704728b8896e367ed108')
                 ])
         e_tree = self.store[new_tree[b'e'][1]]
         self.assertEqual(
             e_tree.items(), [
                 TreeEntry(path=b'f', mode=stat.S_IFDIR,
                           sha=b'24d2c94d8af232b15a0978c006bf61ef4479a0a5')
                 ])
         f_tree = self.store[e_tree[b'f'][1]]
         self.assertEqual(
             f_tree.items(), [
                 TreeEntry(path=b'd', mode=stat.S_IFREG | 0o100644,
                           sha=blob_d.id)
                 ])
 
     def test_delete_blob(self):
         new_tree = commit_tree_changes(
                 self.store, self.store[self.tree_id], [
                     (b'ad/bd/c', None, None)])
         self.assertEqual(set(new_tree), {b'a', b'ad', b'c'})
         ad_tree = self.store[new_tree[b'ad'][1]]
         self.assertEqual(set(ad_tree), {b'b', b'c'})
 
 
 class TestReadPacksFile(TestCase):
 
     def test_read_packs(self):
         self.assertEqual(["pack-1.pack"], list(read_packs_file(BytesIO(b"""P pack-1.pack
 """))))