diff --git a/.github/workflows/pythonpackage.yml b/.github/workflows/pythonpackage.yml
index 2762e93d..c68de5a4 100644
--- a/.github/workflows/pythonpackage.yml
+++ b/.github/workflows/pythonpackage.yml
@@ -1,66 +1,70 @@
 name: Python package
 
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 6 * * *'  # Daily 6AM UTC build
 
 jobs:
   build:
 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: [3.5, 3.6, 3.7, 3.8, 3.9, pypy3]
+        python-version: [3.5, 3.6, 3.7, 3.8, 3.9, 3.10-dev, pypy3]
         exclude:
           # sqlite3 exit handling seems to get in the way
           - os: macos-latest
             python-version: pypy3
           # doesn't support passing in bytestrings to os.scandir
           - os: windows-latest
             python-version: pypy3
           # path encoding
           - os: windows-latest
             python-version: 3.5
           # path encoding
           - os: macos-latest
             python-version: 3.5
       fail-fast: false
 
     steps:
     - uses: actions/checkout@v2
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install native dependencies (Ubuntu)
       run: sudo apt-get update && sudo apt-get install -y libgpgme-dev libgpg-error-dev
       if: "matrix.os == 'ubuntu-latest'"
     - name: Install native dependencies (MacOS)
       run: brew install swig gpgme
       if: "matrix.os == 'macos-latest'"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
         pip install -U pip coverage codecov flake8 fastimport
     - name: Install gpg on supported platforms
       run: pip install -U gpg
       if: "matrix.os != 'windows-latest' && matrix.python-version != 'pypy3'"
     - name: Install mypy
       run: |
-        pip install -U mypy
+        pip install -U mypy types-paramiko types-certifi
       if: "matrix.python-version != 'pypy3'"
     - name: Style checks
       run: |
         python -m flake8
     - name: Typing checks
       run: |
         python -m mypy dulwich
       if: "matrix.python-version != 'pypy3'"
     - name: Build
       run: |
         python setup.py build_ext -i
     - name: Coverage test suite run
       run: |
         python -m coverage run -p -m unittest dulwich.tests.test_suite
     - name: Upload coverage details
       run: |
         codecov
diff --git a/NEWS b/NEWS
index 7eaeae90..953bbaf1 100644
--- a/NEWS
+++ b/NEWS
@@ -1,2246 +1,2267 @@
+0.20.25	2021-08-23
+
+ * Fix ``dulwich`` script when installed via setup.py.
+   (Dan Villiom Podlaski Christiansen)
+
+ * Make default file mask consistent
+   with Git. (Dan Villiom Podlaski Christiansen, #884)
+
+0.20.24	2021-07-18
+
+ * config: disregard UTF-8 BOM when reading file.
+   (Dan Villiom Podlaski Christiansen)
+
+ * Skip lines with spaces only in .gitignore. (Andrey Torsunov, #878)
+
+ * Add a separate HTTPProxyUnauthorized exception for 407 errors.
+   (Jelmer Vernooij, #822)
+
+ * Split out a AbstractHTTPGitClient class.
+   (Jelmer Vernooij)
+
 0.20.23	2021-05-24
 
  * Fix installation of GPG during package publishing.
    (Ruslan Kuprieiev)
 
 0.20.22	2021-05-24
 
  * Prevent removal of refs directory when the last ref is
    deleted. (Jelmer Vernooij)
 
  * Fix filename: MERGE_HEADS => MERGE_HEAD.
    (Jelmer Vernooij, #861)
 
  * For ignored directories, porcelain.add and porcelain.status now only return
    the path to directory itself in the list of ignored paths. Previously, paths
    for all files within the directory would also be included in the list.
    (Peter Rowlands, #853)
 
  * Provide depth argument to ``determine_wants``.
    (Peter Rowlands)
 
  * Various tag signature handling improvements.
    (Daniel Murphy)
 
  * Add separate Tag.verify().  (Peter Rowlands)
 
  * Add support for version 3 index files. (Jelmer Vernooij)
 
  * Fix autocrlf=input handling. (Peter Rowlands, Boris Feld)
 
  * Attempt to find C Git global config on Windows.
    (Peter Rowlands)
 
  API CHANGES
 
  * The APIs for writing and reading individual index entries have changed
    to handle lists of (name, entry) tuples rather than tuples.
 
 0.20.21	2021-03-20
 
  * Add basic support for a GcsObjectStore that stores
    pack files in gcs. (Jelmer Vernooij)
 
  * In porcelain.push, default to local active branch.
    (Jelmer Vernooij, #846)
 
  * Support fetching symrefs.
    (Jelmer Vernooij, #485, #847)
 
  * Add aarch64 wheel building.
    (odidev, Jelmer Vernooij)
 
 0.20.20	2021-03-03
 
  * Implement ``Stash.drop``. (Peter Rowlands)
 
  * Support untracked symlinks to paths outside the
    repository. (Peter Rowlands, #842)
 
 0.20.19	2021-02-11
 
  * Fix handling of negative matches in nested gitignores.
    (Corentin Hembise, #836)
 
 0.20.18	2021-02-04
 
  * Fix formatting in setup.py. (Jelmer Vernooij)
 
  * Add release configuration. (Jelmer Vernooij)
 
 0.20.17	2021-02-04
 
  * credentials: ignore end-of-line character. (Georges Racinet)
 
  * Fix failure in get_untracked_paths when the repository contains symlinks.
    (#830, #793, mattseddon)
 
  * docs: Clarify that Git objects are created on `git add`.
    (Utku Gultopu)
 
 0.20.16	2021-01-16
 
  * Add flag to only attempt to fetch ignored untracked files when specifically requested.
    (Matt Seddon)
 
 0.20.15	2020-12-23
 
  * Add some functions for parsing and writing bundles.
    (Jelmer Vernooij)
 
  * Add ``no_verify`` flag to ``porcelain.commit`` and ``Repo.do_commit``.
    (Peter Rowlands)
 
  * Remove dependency on external mock module.
    (Matěj Cepl, #820)
 
 0.20.14	2020-11-26
 
  * Fix some stash functions on Python 3. (Peter Rowlands)
 
  * Fix handling of relative paths in alternates files on Python 3.
    (Georges Racinet)
 
 0.20.13	2020-11-22
 
  * Add py.typed to allow type checking. (David Caro)
 
  * Add tests demonstrating a bug in the walker code.
    (Doug Hellman)
 
 0.20.11	2020-10-30
 
  * Fix wheels build on Linux. (Ruslan Kuprieiev)
 
  * Enable wheels build for Python 3.9 on Linux. (Jelmer Vernooij)
 
 0.20.8	2020-10-29
 
  * Build wheels on Mac OS X / Windows for Python 3.9.
    (Jelmer Vernooij)
 
 0.20.7	2020-10-29
 
  * Check core.repositoryformatversion. (Jelmer Vernooij, #803)
 
  * Fix ACK/NACK handling in archive command handling in dulwich.client.
    (DzmitrySudnik, #805)
 
 0.20.6	2020-08-29
 
  * Add a ``RefsContainer.watch`` interface.
    (Jelmer Vernooij, #751)
 
  * Fix pushing of new branches from porcelain.push.
    (Jelmer Vernooij, #788)
 
  * Honor shallows when pushing from a shallow clone.
    (Jelmer Vernooij, #794)
 
  * Fix porcelain.path_to_tree_path for Python 3.5.
    (Boris Feld, #777)
 
  * Add support for honor proxy environment variables for HTTP.
    (Aurélien Campéas, #797)
 
 0.20.5	2020-06-22
 
  * Print a clearer exception when setup.py is executed on Python < 3.5.
    (Jelmer Vernooij, #783)
 
  * Send an empty pack to clients if they requested objects, even if they
    already have those objects. Thanks to Martijn Pieters for
    the detailed bug report. (Jelmer Vernooij, #781)
 
  * porcelain.pull: Don't ask for objects that we already have.
    (Jelmer Vernooij, #782)
 
  * Add LCA implementation. (Kevin Hendricks)
 
  * Add functionality for finding the merge base. (Kevin Hendricks)
 
  * Check for diverged branches during push.
    (Jelmer Vernooij, #494)
 
  * Check for fast-forward during pull. (Jelmer Vernooij, #666)
 
  * Return a SendPackResult object from
    GitClient.send_pack(). (Jelmer Vernooij)
 
  * ``GitClient.send_pack`` now sets the ``ref_status`` attribute
    on its return value to a dictionary mapping ref names
    to error messages. Previously, it raised UpdateRefsError
    if any of the refs failed to update.
    (Jelmer Vernooij, #780)
 
  * Add a ``porcelain.Error`` object that most errors in porcelain
    derive from. (Jelmer Vernooij)
 
  * Fix argument parsing in dulwich command-line app.
    (Jelmer Vernooij, #784)
 
 0.20.3	2020-06-14
 
  * Add support for remembering remote refs after push/pull.
    (Jelmer Vernooij, #752)
 
  * Support passing tree and output encoding to
    dulwich.patch.unified_diff. (Jelmer Vernooij, #763)
 
  * Fix pushing of new refs over HTTP(S) when there are
    no new objects to be sent.
    (Jelmer Vernooij, #739)
 
  * Raise new error HTTPUnauthorized when the server sends
    back a 401. The client can then retry with credentials.
    (Jelmer Vernooij, #691)
 
  * Move the guts of bin/dulwich to dulwich.cli, so it is easier to
    test or import. (Jelmer Vernooij)
 
  * Install dulwich script from entry_points when setuptools is available,
    making it slightly easier to use on Windows. (Jelmer Vernooij, #540)
 
  * Set python_requires>=3.5 in setup.py. (Manuel Jacob)
 
 0.20.2	2020-06-01
 
  * Brown bag release to fix uploads of Windows wheels.
 
 0.20.1	2020-06-01
 
  * Publish binary wheels for: Windows, Linux, Mac OS X.
    (Jelmer Vernooij, #711, #710, #629)
 
 0.20.0	2020-06-01
 
  * Drop support for Python 2. (Jelmer Vernooij)
 
  * Only return files from the loose store that look like git objects.
    (Nicolas Dandrimont)
 
  * Ignore agent= capability if sent by client.
    (Jelmer Vernooij)
 
  * 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)
+   (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/.
     (Jelmer Vernooij, CVE-2014-9706)
 
   * 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/PKG-INFO b/PKG-INFO
index e54aeeed..f42454ce 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,126 +1,130 @@
 Metadata-Version: 2.1
 Name: dulwich
-Version: 0.20.23
+Version: 0.20.25
 Summary: Python Git Library
 Home-page: https://www.dulwich.io/
 Author: Jelmer Vernooij
 Author-email: jelmer@jelmer.uk
 License: Apachev2 or later or GPLv2
 Project-URL: Bug Tracker, https://github.com/dulwich/dulwich/issues
 Project-URL: Repository, https://www.dulwich.io/code/
 Project-URL: GitHub, https://github.com/dulwich/dulwich
-Description: Dulwich
-        =======
-        
-        This is the Dulwich project.
-        
-        It aims to provide an interface to git repos (both local and remote) that
-        doesn't call out to git directly but instead uses pure Python.
-        
-        **Main website**: <https://www.dulwich.io/>
-        
-        **License**: Apache License, version 2 or GNU General Public License, version 2 or later.
-        
-        The project is named after the part of London that Mr. and Mrs. Git live in
-        in the particular Monty Python sketch.
-        
-        Installation
-        ------------
-        
-        By default, Dulwich' setup.py will attempt to build and install the optional C
-        extensions. The reason for this is that they significantly improve the performance
-        since some low-level operations that are executed often are much slower in CPython.
-        
-        If you don't want to install the C bindings, specify the --pure argument to setup.py::
-        
-            $ python setup.py --pure install
-        
-        or if you are installing from pip::
-        
-            $ pip install dulwich --global-option="--pure"
-        
-        Note that you can also specify --global-option in a
-        `requirements.txt <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_
-        file, e.g. like this::
-        
-            dulwich --global-option=--pure
-        
-        Getting started
-        ---------------
-        
-        Dulwich comes with both a lower-level API and higher-level plumbing ("porcelain").
-        
-        For example, to use the lower level API to access the commit message of the
-        last commit::
-        
-            >>> from dulwich.repo import Repo
-            >>> r = Repo('.')
-            >>> r.head()
-            '57fbe010446356833a6ad1600059d80b1e731e15'
-            >>> c = r[r.head()]
-            >>> c
-            <Commit 015fc1267258458901a94d228e39f0a378370466>
-            >>> c.message
-            'Add note about encoding.\n'
-        
-        And to print it using porcelain::
-        
-            >>> from dulwich import porcelain
-            >>> porcelain.log('.', max_entries=1)
-            --------------------------------------------------
-            commit: 57fbe010446356833a6ad1600059d80b1e731e15
-            Author: Jelmer Vernooij <jelmer@jelmer.uk>
-            Date:   Sat Apr 29 2017 23:57:34 +0000
-        
-            Add note about encoding.
-        
-        Further documentation
-        ---------------------
-        
-        The dulwich documentation can be found in docs/ and built by running ``make
-        doc``. It can also be found `on the web <https://www.dulwich.io/docs/>`_.
-        
-        Help
-        ----
-        
-        There is a *#dulwich* IRC channel on the `OFTC <https://www.oftc.net/>`_, and
-        `dulwich-announce <https://groups.google.com/forum/#!forum/dulwich-announce>`_
-        and `dulwich-discuss <https://groups.google.com/forum/#!forum/dulwich-discuss>`_
-        mailing lists.
-        
-        Contributing
-        ------------
-        
-        For a full list of contributors, see the git logs or `AUTHORS <AUTHORS>`_.
-        
-        If you'd like to contribute to Dulwich, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
-        file and `list of open issues <https://github.com/dulwich/dulwich/issues>`_.
-        
-        Supported versions of Python
-        ----------------------------
-        
-        At the moment, Dulwich supports (and is tested on) CPython 3.5 and later and
-        Pypy.
-        
-        The latest release series to support Python 2.x was the 0.19 series. See
-        the 0.19 branch in the Dulwich git repository.
-        
 Keywords: git vcs
 Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Topic :: Software Development :: Version Control
 Requires-Python: >=3.5
 Provides-Extra: fastimport
 Provides-Extra: https
 Provides-Extra: pgp
 Provides-Extra: watch
+License-File: COPYING
+License-File: AUTHORS
+
+Dulwich
+=======
+
+This is the Dulwich project.
+
+It aims to provide an interface to git repos (both local and remote) that
+doesn't call out to git directly but instead uses pure Python.
+
+**Main website**: <https://www.dulwich.io/>
+
+**License**: Apache License, version 2 or GNU General Public License, version 2 or later.
+
+The project is named after the part of London that Mr. and Mrs. Git live in
+in the particular Monty Python sketch.
+
+Installation
+------------
+
+By default, Dulwich' setup.py will attempt to build and install the optional C
+extensions. The reason for this is that they significantly improve the performance
+since some low-level operations that are executed often are much slower in CPython.
+
+If you don't want to install the C bindings, specify the --pure argument to setup.py::
+
+    $ python setup.py --pure install
+
+or if you are installing from pip::
+
+    $ pip install dulwich --global-option="--pure"
+
+Note that you can also specify --global-option in a
+`requirements.txt <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_
+file, e.g. like this::
+
+    dulwich --global-option=--pure
+
+Getting started
+---------------
+
+Dulwich comes with both a lower-level API and higher-level plumbing ("porcelain").
+
+For example, to use the lower level API to access the commit message of the
+last commit::
+
+    >>> from dulwich.repo import Repo
+    >>> r = Repo('.')
+    >>> r.head()
+    '57fbe010446356833a6ad1600059d80b1e731e15'
+    >>> c = r[r.head()]
+    >>> c
+    <Commit 015fc1267258458901a94d228e39f0a378370466>
+    >>> c.message
+    'Add note about encoding.\n'
+
+And to print it using porcelain::
+
+    >>> from dulwich import porcelain
+    >>> porcelain.log('.', max_entries=1)
+    --------------------------------------------------
+    commit: 57fbe010446356833a6ad1600059d80b1e731e15
+    Author: Jelmer Vernooij <jelmer@jelmer.uk>
+    Date:   Sat Apr 29 2017 23:57:34 +0000
+
+    Add note about encoding.
+
+Further documentation
+---------------------
+
+The dulwich documentation can be found in docs/ and built by running ``make
+doc``. It can also be found `on the web <https://www.dulwich.io/docs/>`_.
+
+Help
+----
+
+There is a *#dulwich* IRC channel on the `OFTC <https://www.oftc.net/>`_, and
+`dulwich-announce <https://groups.google.com/forum/#!forum/dulwich-announce>`_
+and `dulwich-discuss <https://groups.google.com/forum/#!forum/dulwich-discuss>`_
+mailing lists.
+
+Contributing
+------------
+
+For a full list of contributors, see the git logs or `AUTHORS <AUTHORS>`_.
+
+If you'd like to contribute to Dulwich, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
+file and `list of open issues <https://github.com/dulwich/dulwich/issues>`_.
+
+Supported versions of Python
+----------------------------
+
+At the moment, Dulwich supports (and is tested on) CPython 3.5 and later and
+Pypy.
+
+The latest release series to support Python 2.x was the 0.19 series. See
+the 0.19 branch in the Dulwich git repository.
+
+
diff --git a/build.cmd b/build.cmd
deleted file mode 100644
index 23df2b69..00000000
--- a/build.cmd
+++ /dev/null
@@ -1,21 +0,0 @@
-@echo off
-:: To build extensions for 64 bit Python 3, we need to configure environment
-:: variables to use the MSVC 2010 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 4
-::
-:: More details at:
-:: https://github.com/cython/cython/wiki/CythonExtensionsOnWindows
-
-IF "%DISTUTILS_USE_SDK%"=="1" (
-    ECHO Configuring environment to build with MSVC on a 64bit architecture
-    ECHO Using Windows SDK 7.1
-    "C:\Program Files\Microsoft SDKs\Windows\v7.1\Setup\WindowsSdkVer.exe" -q -version:v7.1
-    CALL "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /x64 /release
-    SET MSSdk=1
-    REM Need the following to allow tox to see the SDK compiler
-    SET TOX_TESTENV_PASSENV=DISTUTILS_USE_SDK MSSdk INCLUDE LIB
-) ELSE (
-    ECHO Using default MSVC build environment
-)
-
-CALL %*
diff --git a/dulwich.egg-info/PKG-INFO b/dulwich.egg-info/PKG-INFO
index e54aeeed..f42454ce 100644
--- a/dulwich.egg-info/PKG-INFO
+++ b/dulwich.egg-info/PKG-INFO
@@ -1,126 +1,130 @@
 Metadata-Version: 2.1
 Name: dulwich
-Version: 0.20.23
+Version: 0.20.25
 Summary: Python Git Library
 Home-page: https://www.dulwich.io/
 Author: Jelmer Vernooij
 Author-email: jelmer@jelmer.uk
 License: Apachev2 or later or GPLv2
 Project-URL: Bug Tracker, https://github.com/dulwich/dulwich/issues
 Project-URL: Repository, https://www.dulwich.io/code/
 Project-URL: GitHub, https://github.com/dulwich/dulwich
-Description: Dulwich
-        =======
-        
-        This is the Dulwich project.
-        
-        It aims to provide an interface to git repos (both local and remote) that
-        doesn't call out to git directly but instead uses pure Python.
-        
-        **Main website**: <https://www.dulwich.io/>
-        
-        **License**: Apache License, version 2 or GNU General Public License, version 2 or later.
-        
-        The project is named after the part of London that Mr. and Mrs. Git live in
-        in the particular Monty Python sketch.
-        
-        Installation
-        ------------
-        
-        By default, Dulwich' setup.py will attempt to build and install the optional C
-        extensions. The reason for this is that they significantly improve the performance
-        since some low-level operations that are executed often are much slower in CPython.
-        
-        If you don't want to install the C bindings, specify the --pure argument to setup.py::
-        
-            $ python setup.py --pure install
-        
-        or if you are installing from pip::
-        
-            $ pip install dulwich --global-option="--pure"
-        
-        Note that you can also specify --global-option in a
-        `requirements.txt <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_
-        file, e.g. like this::
-        
-            dulwich --global-option=--pure
-        
-        Getting started
-        ---------------
-        
-        Dulwich comes with both a lower-level API and higher-level plumbing ("porcelain").
-        
-        For example, to use the lower level API to access the commit message of the
-        last commit::
-        
-            >>> from dulwich.repo import Repo
-            >>> r = Repo('.')
-            >>> r.head()
-            '57fbe010446356833a6ad1600059d80b1e731e15'
-            >>> c = r[r.head()]
-            >>> c
-            <Commit 015fc1267258458901a94d228e39f0a378370466>
-            >>> c.message
-            'Add note about encoding.\n'
-        
-        And to print it using porcelain::
-        
-            >>> from dulwich import porcelain
-            >>> porcelain.log('.', max_entries=1)
-            --------------------------------------------------
-            commit: 57fbe010446356833a6ad1600059d80b1e731e15
-            Author: Jelmer Vernooij <jelmer@jelmer.uk>
-            Date:   Sat Apr 29 2017 23:57:34 +0000
-        
-            Add note about encoding.
-        
-        Further documentation
-        ---------------------
-        
-        The dulwich documentation can be found in docs/ and built by running ``make
-        doc``. It can also be found `on the web <https://www.dulwich.io/docs/>`_.
-        
-        Help
-        ----
-        
-        There is a *#dulwich* IRC channel on the `OFTC <https://www.oftc.net/>`_, and
-        `dulwich-announce <https://groups.google.com/forum/#!forum/dulwich-announce>`_
-        and `dulwich-discuss <https://groups.google.com/forum/#!forum/dulwich-discuss>`_
-        mailing lists.
-        
-        Contributing
-        ------------
-        
-        For a full list of contributors, see the git logs or `AUTHORS <AUTHORS>`_.
-        
-        If you'd like to contribute to Dulwich, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
-        file and `list of open issues <https://github.com/dulwich/dulwich/issues>`_.
-        
-        Supported versions of Python
-        ----------------------------
-        
-        At the moment, Dulwich supports (and is tested on) CPython 3.5 and later and
-        Pypy.
-        
-        The latest release series to support Python 2.x was the 0.19 series. See
-        the 0.19 branch in the Dulwich git repository.
-        
 Keywords: git vcs
 Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Topic :: Software Development :: Version Control
 Requires-Python: >=3.5
 Provides-Extra: fastimport
 Provides-Extra: https
 Provides-Extra: pgp
 Provides-Extra: watch
+License-File: COPYING
+License-File: AUTHORS
+
+Dulwich
+=======
+
+This is the Dulwich project.
+
+It aims to provide an interface to git repos (both local and remote) that
+doesn't call out to git directly but instead uses pure Python.
+
+**Main website**: <https://www.dulwich.io/>
+
+**License**: Apache License, version 2 or GNU General Public License, version 2 or later.
+
+The project is named after the part of London that Mr. and Mrs. Git live in
+in the particular Monty Python sketch.
+
+Installation
+------------
+
+By default, Dulwich' setup.py will attempt to build and install the optional C
+extensions. The reason for this is that they significantly improve the performance
+since some low-level operations that are executed often are much slower in CPython.
+
+If you don't want to install the C bindings, specify the --pure argument to setup.py::
+
+    $ python setup.py --pure install
+
+or if you are installing from pip::
+
+    $ pip install dulwich --global-option="--pure"
+
+Note that you can also specify --global-option in a
+`requirements.txt <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_
+file, e.g. like this::
+
+    dulwich --global-option=--pure
+
+Getting started
+---------------
+
+Dulwich comes with both a lower-level API and higher-level plumbing ("porcelain").
+
+For example, to use the lower level API to access the commit message of the
+last commit::
+
+    >>> from dulwich.repo import Repo
+    >>> r = Repo('.')
+    >>> r.head()
+    '57fbe010446356833a6ad1600059d80b1e731e15'
+    >>> c = r[r.head()]
+    >>> c
+    <Commit 015fc1267258458901a94d228e39f0a378370466>
+    >>> c.message
+    'Add note about encoding.\n'
+
+And to print it using porcelain::
+
+    >>> from dulwich import porcelain
+    >>> porcelain.log('.', max_entries=1)
+    --------------------------------------------------
+    commit: 57fbe010446356833a6ad1600059d80b1e731e15
+    Author: Jelmer Vernooij <jelmer@jelmer.uk>
+    Date:   Sat Apr 29 2017 23:57:34 +0000
+
+    Add note about encoding.
+
+Further documentation
+---------------------
+
+The dulwich documentation can be found in docs/ and built by running ``make
+doc``. It can also be found `on the web <https://www.dulwich.io/docs/>`_.
+
+Help
+----
+
+There is a *#dulwich* IRC channel on the `OFTC <https://www.oftc.net/>`_, and
+`dulwich-announce <https://groups.google.com/forum/#!forum/dulwich-announce>`_
+and `dulwich-discuss <https://groups.google.com/forum/#!forum/dulwich-discuss>`_
+mailing lists.
+
+Contributing
+------------
+
+For a full list of contributors, see the git logs or `AUTHORS <AUTHORS>`_.
+
+If you'd like to contribute to Dulwich, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
+file and `list of open issues <https://github.com/dulwich/dulwich/issues>`_.
+
+Supported versions of Python
+----------------------------
+
+At the moment, Dulwich supports (and is tested on) CPython 3.5 and later and
+Pypy.
+
+The latest release series to support Python 2.x was the 0.19 series. See
+the 0.19 branch in the Dulwich git repository.
+
+
diff --git a/dulwich.egg-info/SOURCES.txt b/dulwich.egg-info/SOURCES.txt
index 7e9c7a83..75bc62eb 100644
--- a/dulwich.egg-info/SOURCES.txt
+++ b/dulwich.egg-info/SOURCES.txt
@@ -1,242 +1,243 @@
 .coveragerc
 .deepsource.toml
 .flake8
 .gitignore
 .mailmap
 .testr.conf
 AUTHORS
 CODE_OF_CONDUCT.md
 CONTRIBUTING.rst
 COPYING
 MANIFEST.in
 Makefile
 NEWS
 README.rst
 README.swift.rst
 SECURITY.md
 TODO
-build.cmd
 dulwich.cfg
 releaser.conf
 requirements.txt
 setup.cfg
 setup.py
 status.yaml
 tox.ini
 .github/workflows/pythonpackage.yml
 .github/workflows/pythonpublish.yml
 bin/dul-receive-pack
 bin/dul-upload-pack
 bin/dulwich
 devscripts/PREAMBLE.c
 devscripts/PREAMBLE.py
 devscripts/replace-preamble.sh
 docs/Makefile
 docs/conf.py
 docs/index.txt
 docs/make.bat
 docs/performance.txt
 docs/protocol.txt
 docs/api/index.txt
 docs/tutorial/.gitignore
 docs/tutorial/Makefile
 docs/tutorial/conclusion.txt
 docs/tutorial/encoding.txt
 docs/tutorial/file-format.txt
 docs/tutorial/index.txt
 docs/tutorial/introduction.txt
 docs/tutorial/object-store.txt
 docs/tutorial/porcelain.txt
 docs/tutorial/remote.txt
 docs/tutorial/repo.txt
 docs/tutorial/tag.txt
 dulwich/__init__.py
+dulwich/__main__.py
 dulwich/_diff_tree.c
 dulwich/_objects.c
 dulwich/_pack.c
 dulwich/archive.py
 dulwich/bundle.py
 dulwich/cli.py
 dulwich/client.py
 dulwich/config.py
 dulwich/diff_tree.py
 dulwich/errors.py
 dulwich/fastexport.py
 dulwich/file.py
 dulwich/graph.py
 dulwich/greenthreads.py
 dulwich/hooks.py
 dulwich/ignore.py
 dulwich/index.py
 dulwich/lfs.py
 dulwich/line_ending.py
 dulwich/log_utils.py
 dulwich/lru_cache.py
 dulwich/mailmap.py
 dulwich/object_store.py
 dulwich/objects.py
 dulwich/objectspec.py
 dulwich/pack.py
 dulwich/patch.py
 dulwich/porcelain.py
 dulwich/protocol.py
 dulwich/py.typed
 dulwich/reflog.py
 dulwich/refs.py
 dulwich/repo.py
 dulwich/server.py
 dulwich/stash.py
 dulwich/stdint.h
 dulwich/walk.py
 dulwich/web.py
 dulwich.egg-info/PKG-INFO
 dulwich.egg-info/SOURCES.txt
 dulwich.egg-info/dependency_links.txt
 dulwich.egg-info/entry_points.txt
+dulwich.egg-info/not-zip-safe
 dulwich.egg-info/requires.txt
 dulwich.egg-info/top_level.txt
 dulwich/cloud/__init__.py
 dulwich/cloud/gcs.py
 dulwich/contrib/README.md
 dulwich/contrib/__init__.py
 dulwich/contrib/diffstat.py
 dulwich/contrib/paramiko_vendor.py
 dulwich/contrib/release_robot.py
 dulwich/contrib/swift.py
 dulwich/contrib/test_paramiko_vendor.py
 dulwich/contrib/test_release_robot.py
 dulwich/contrib/test_swift.py
 dulwich/contrib/test_swift_smoke.py
 dulwich/tests/__init__.py
 dulwich/tests/test_archive.py
 dulwich/tests/test_blackbox.py
 dulwich/tests/test_bundle.py
 dulwich/tests/test_client.py
 dulwich/tests/test_config.py
 dulwich/tests/test_diff_tree.py
 dulwich/tests/test_fastexport.py
 dulwich/tests/test_file.py
 dulwich/tests/test_grafts.py
 dulwich/tests/test_graph.py
 dulwich/tests/test_greenthreads.py
 dulwich/tests/test_hooks.py
 dulwich/tests/test_ignore.py
 dulwich/tests/test_index.py
 dulwich/tests/test_lfs.py
 dulwich/tests/test_line_ending.py
 dulwich/tests/test_lru_cache.py
 dulwich/tests/test_mailmap.py
 dulwich/tests/test_missing_obj_finder.py
 dulwich/tests/test_object_store.py
 dulwich/tests/test_objects.py
 dulwich/tests/test_objectspec.py
 dulwich/tests/test_pack.py
 dulwich/tests/test_patch.py
 dulwich/tests/test_porcelain.py
 dulwich/tests/test_protocol.py
 dulwich/tests/test_reflog.py
 dulwich/tests/test_refs.py
 dulwich/tests/test_repository.py
 dulwich/tests/test_server.py
 dulwich/tests/test_stash.py
 dulwich/tests/test_utils.py
 dulwich/tests/test_walk.py
 dulwich/tests/test_web.py
 dulwich/tests/utils.py
 dulwich/tests/compat/__init__.py
 dulwich/tests/compat/server_utils.py
 dulwich/tests/compat/test_client.py
 dulwich/tests/compat/test_pack.py
 dulwich/tests/compat/test_patch.py
 dulwich/tests/compat/test_porcelain.py
 dulwich/tests/compat/test_repository.py
 dulwich/tests/compat/test_server.py
 dulwich/tests/compat/test_utils.py
 dulwich/tests/compat/test_web.py
 dulwich/tests/compat/utils.py
 dulwich/tests/data/blobs/11/11111111111111111111111111111111111111
 dulwich/tests/data/blobs/6f/670c0fb53f9463760b7295fbb814e965fb20c8
 dulwich/tests/data/blobs/95/4a536f7819d40e6f637f849ee187dd10066349
 dulwich/tests/data/blobs/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
 dulwich/tests/data/commits/0d/89f20333fbb1d2f3a94da77f4981373d8f4310
 dulwich/tests/data/commits/5d/ac377bdded4c9aeb8dff595f0faeebcc8498cc
 dulwich/tests/data/commits/60/dacdc733de308bb77bb76ce0fb0f9b44c9769e
 dulwich/tests/data/indexes/index
 dulwich/tests/data/packs/pack-bc63ddad95e7321ee734ea11a7a62d314e0d7481.idx
 dulwich/tests/data/packs/pack-bc63ddad95e7321ee734ea11a7a62d314e0d7481.pack
 dulwich/tests/data/repos/.gitattributes
 dulwich/tests/data/repos/issue88_expect_ack_nak_client.export
 dulwich/tests/data/repos/issue88_expect_ack_nak_other.export
 dulwich/tests/data/repos/issue88_expect_ack_nak_server.export
 dulwich/tests/data/repos/server_new.export
 dulwich/tests/data/repos/server_old.export
 dulwich/tests/data/repos/a.git/HEAD
 dulwich/tests/data/repos/a.git/packed-refs
 dulwich/tests/data/repos/a.git/objects/28/237f4dc30d0d462658d6b937b08a0f0b6ef55a
 dulwich/tests/data/repos/a.git/objects/2a/72d929692c41d8554c07f6301757ba18a65d91
 dulwich/tests/data/repos/a.git/objects/4e/f30bbfe26431a69c3820d3a683df54d688f2ec
 dulwich/tests/data/repos/a.git/objects/4f/2e6529203aa6d44b5af6e3292c837ceda003f9
 dulwich/tests/data/repos/a.git/objects/7d/9a07d797595ef11344549b8d08198e48c15364
 dulwich/tests/data/repos/a.git/objects/a2/96d0bb611188cabb256919f36bc30117cca005
 dulwich/tests/data/repos/a.git/objects/a9/0fa2d900a17e99b433217e988c4eb4a2e9a097
 dulwich/tests/data/repos/a.git/objects/b0/931cadc54336e78a1d980420e3268903b57a50
 dulwich/tests/data/repos/a.git/objects/ff/d47d45845a8f6576491e1edb97e3fe6a850e7f
 dulwich/tests/data/repos/a.git/refs/heads/master
 dulwich/tests/data/repos/a.git/refs/tags/mytag
 dulwich/tests/data/repos/empty.git/HEAD
 dulwich/tests/data/repos/empty.git/config
 dulwich/tests/data/repos/empty.git/objects/info/.gitignore
 dulwich/tests/data/repos/empty.git/objects/pack/.gitignore
 dulwich/tests/data/repos/empty.git/refs/heads/.gitignore
 dulwich/tests/data/repos/empty.git/refs/tags/.gitignore
 dulwich/tests/data/repos/ooo_merge.git/HEAD
 dulwich/tests/data/repos/ooo_merge.git/objects/29/69be3e8ee1c0222396a5611407e4769f14e54b
 dulwich/tests/data/repos/ooo_merge.git/objects/38/74e9c60a6d149c44c928140f250d81e6381520
 dulwich/tests/data/repos/ooo_merge.git/objects/6f/670c0fb53f9463760b7295fbb814e965fb20c8
 dulwich/tests/data/repos/ooo_merge.git/objects/70/c190eb48fa8bbb50ddc692a17b44cb781af7f6
 dulwich/tests/data/repos/ooo_merge.git/objects/76/01d7f6231db6a57f7bbb79ee52e4d462fd44d1
 dulwich/tests/data/repos/ooo_merge.git/objects/90/182552c4a85a45ec2a835cadc3451bebdfe870
 dulwich/tests/data/repos/ooo_merge.git/objects/95/4a536f7819d40e6f637f849ee187dd10066349
 dulwich/tests/data/repos/ooo_merge.git/objects/b2/a2766a2879c209ab1176e7e778b81ae422eeaa
 dulwich/tests/data/repos/ooo_merge.git/objects/f5/07291b64138b875c28e03469025b1ea20bc614
 dulwich/tests/data/repos/ooo_merge.git/objects/f9/e39b120c68182a4ba35349f832d0e4e61f485c
 dulwich/tests/data/repos/ooo_merge.git/objects/fb/5b0425c7ce46959bec94d54b9a157645e114f5
 dulwich/tests/data/repos/ooo_merge.git/refs/heads/master
 dulwich/tests/data/repos/refs.git/HEAD
 dulwich/tests/data/repos/refs.git/packed-refs
 dulwich/tests/data/repos/refs.git/objects/3b/9e5457140e738c2dcd39bf6d7acf88379b90d1
 dulwich/tests/data/repos/refs.git/objects/3e/c9c43c84ff242e3ef4a9fc5bc111fd780a76a8
 dulwich/tests/data/repos/refs.git/objects/42/d06bd4b77fed026b154d16493e5deab78f02ec
 dulwich/tests/data/repos/refs.git/objects/a1/8114c31713746a33a2e70d9914d1ef3e781425
 dulwich/tests/data/repos/refs.git/objects/cd/a609072918d7b70057b6bef9f4c2537843fcfe
 dulwich/tests/data/repos/refs.git/objects/df/6800012397fb85c56e7418dd4eb9405dee075c
 dulwich/tests/data/repos/refs.git/refs/heads/40-char-ref-aaaaaaaaaaaaaaaaaa
 dulwich/tests/data/repos/refs.git/refs/heads/loop
 dulwich/tests/data/repos/refs.git/refs/heads/master
 dulwich/tests/data/repos/refs.git/refs/tags/refs-0.2
 dulwich/tests/data/repos/simple_merge.git/HEAD
 dulwich/tests/data/repos/simple_merge.git/objects/0d/89f20333fbb1d2f3a94da77f4981373d8f4310
 dulwich/tests/data/repos/simple_merge.git/objects/1b/6318f651a534b38f9c7aedeebbd56c1e896853
 dulwich/tests/data/repos/simple_merge.git/objects/29/69be3e8ee1c0222396a5611407e4769f14e54b
 dulwich/tests/data/repos/simple_merge.git/objects/4c/ffe90e0a41ad3f5190079d7c8f036bde29cbe6
 dulwich/tests/data/repos/simple_merge.git/objects/5d/ac377bdded4c9aeb8dff595f0faeebcc8498cc
 dulwich/tests/data/repos/simple_merge.git/objects/60/dacdc733de308bb77bb76ce0fb0f9b44c9769e
 dulwich/tests/data/repos/simple_merge.git/objects/6f/670c0fb53f9463760b7295fbb814e965fb20c8
 dulwich/tests/data/repos/simple_merge.git/objects/70/c190eb48fa8bbb50ddc692a17b44cb781af7f6
 dulwich/tests/data/repos/simple_merge.git/objects/90/182552c4a85a45ec2a835cadc3451bebdfe870
 dulwich/tests/data/repos/simple_merge.git/objects/95/4a536f7819d40e6f637f849ee187dd10066349
 dulwich/tests/data/repos/simple_merge.git/objects/ab/64bbdcc51b170d21588e5c5d391ee5c0c96dfd
 dulwich/tests/data/repos/simple_merge.git/objects/d4/bdad6549dfedf25d3b89d21f506aff575b28a7
 dulwich/tests/data/repos/simple_merge.git/objects/d8/0c186a03f423a81b39df39dc87fd269736ca86
 dulwich/tests/data/repos/simple_merge.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
 dulwich/tests/data/repos/simple_merge.git/refs/heads/master
 dulwich/tests/data/repos/submodule/dotgit
 dulwich/tests/data/tags/71/033db03a03c6a36721efcf1968dd8f8e0cf023
 dulwich/tests/data/trees/70/c190eb48fa8bbb50ddc692a17b44cb781af7f6
 examples/clone.py
 examples/config.py
 examples/diff.py
 examples/gcs.py
 examples/latest_change.py
 examples/memoryrepo.py
 examples/rename-branch.py
\ No newline at end of file
diff --git a/dulwich.egg-info/not-zip-safe b/dulwich.egg-info/not-zip-safe
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/dulwich.egg-info/not-zip-safe
@@ -0,0 +1 @@
+
diff --git a/dulwich/__init__.py b/dulwich/__init__.py
index 46661a03..17705982 100644
--- a/dulwich/__init__.py
+++ b/dulwich/__init__.py
@@ -1,25 +1,25 @@
 # __init__.py -- The git module of dulwich
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 # 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.
 #
 
 
 """Python implementation of the Git file formats and protocols."""
 
-__version__ = (0, 20, 23)
+__version__ = (0, 20, 25)
diff --git a/dulwich/__main__.py b/dulwich/__main__.py
new file mode 100644
index 00000000..3453a7e6
--- /dev/null
+++ b/dulwich/__main__.py
@@ -0,0 +1,4 @@
+from . import cli
+
+if __name__ == "__main__":
+    cli._main()
diff --git a/dulwich/cli.py b/dulwich/cli.py
index bcdd094b..d0cedf74 100755
--- a/dulwich/cli.py
+++ b/dulwich/cli.py
@@ -1,755 +1,759 @@
 #!/usr/bin/python3 -u
 #
 # dulwich - Simple command-line interface to Dulwich
 # Copyright (C) 2008-2011 Jelmer Vernooij <jelmer@jelmer.uk>
 # vim: expandtab
 #
 # 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.
 #
 
 """Simple command-line interface to Dulwich>
 
 This is a very simple command-line wrapper for Dulwich. It is by
 no means intended to be a full-blown Git command-line interface but just
 a way to test Dulwich.
 """
 
 import os
 import sys
 from getopt import getopt
 import argparse
 import optparse
 import signal
 from typing import Dict, Type
 
 from dulwich import porcelain
 from dulwich.client import get_transport_and_path
 from dulwich.errors import ApplyDeltaError
 from dulwich.index import Index
 from dulwich.pack import Pack, sha_to_hex
 from dulwich.patch import write_tree_diff
 from dulwich.repo import Repo
 
 
 def signal_int(signal, frame):
     sys.exit(1)
 
 
 def signal_quit(signal, frame):
     import pdb
 
     pdb.set_trace()
 
 
 class Command(object):
     """A Dulwich subcommand."""
 
     def run(self, args):
         """Run the command."""
         raise NotImplementedError(self.run)
 
 
 class cmd_archive(Command):
     def run(self, args):
         parser = argparse.ArgumentParser()
         parser.add_argument(
             "--remote",
             type=str,
             help="Retrieve archive from specified remote repo",
         )
         parser.add_argument('committish', type=str, nargs='?')
         args = parser.parse_args(args)
         if args.remote:
             client, path = get_transport_and_path(args.remote)
             client.archive(
                 path,
                 args.committish,
                 sys.stdout.write,
                 write_error=sys.stderr.write,
             )
         else:
             porcelain.archive(
                 ".", args.committish, outstream=sys.stdout.buffer,
                 errstream=sys.stderr
             )
 
 
 class cmd_add(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         args = parser.parse_args(argv)
 
         porcelain.add(".", paths=args)
 
 
 class cmd_rm(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         args = parser.parse_args(argv)
 
         porcelain.rm(".", paths=args)
 
 
 class cmd_fetch_pack(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         parser.add_argument('--all', action='store_true')
         parser.add_argument('location', nargs='?', type=str)
         args = parser.parse_args(argv)
         client, path = get_transport_and_path(args.location)
         r = Repo(".")
         if args.all:
             determine_wants = r.object_store.determine_wants_all
         else:
 
             def determine_wants(x, **kwargs):
                 return [y for y in args if y not in r.object_store]
 
         client.fetch(path, r, determine_wants)
 
 
 class cmd_fetch(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         opts = dict(opts)
         client, path = get_transport_and_path(args.pop(0))
         r = Repo(".")
         refs = client.fetch(path, r, progress=sys.stdout.write)
         print("Remote refs:")
         for item in refs.items():
             print("%s -> %s" % item)
 
 
 class cmd_fsck(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         opts = dict(opts)
         for (obj, msg) in porcelain.fsck("."):
             print("%s: %s" % (obj, msg))
 
 
 class cmd_log(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "--reverse",
             dest="reverse",
             action="store_true",
             help="Reverse order in which entries are printed",
         )
         parser.add_option(
             "--name-status",
             dest="name_status",
             action="store_true",
             help="Print name/status for each changed file",
         )
         options, args = parser.parse_args(args)
 
         porcelain.log(
             ".",
             paths=args,
             reverse=options.reverse,
             name_status=options.name_status,
             outstream=sys.stdout,
         )
 
 
 class cmd_diff(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
 
         if args == []:
             print("Usage: dulwich diff COMMITID")
             sys.exit(1)
 
         r = Repo(".")
         commit_id = args[0]
         commit = r[commit_id]
         parent_commit = r[commit.parents[0]]
         write_tree_diff(sys.stdout, r.object_store, parent_commit.tree, commit.tree)
 
 
 class cmd_dump_pack(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
 
         if args == []:
             print("Usage: dulwich dump-pack FILENAME")
             sys.exit(1)
 
         basename, _ = os.path.splitext(args[0])
         x = Pack(basename)
         print("Object names checksum: %s" % x.name())
         print("Checksum: %s" % sha_to_hex(x.get_stored_checksum()))
         if not x.check():
             print("CHECKSUM DOES NOT MATCH")
         print("Length: %d" % len(x))
         for name in x:
             try:
                 print("\t%s" % x[name])
             except KeyError as k:
                 print("\t%s: Unable to resolve base %s" % (name, k))
             except ApplyDeltaError as e:
                 print("\t%s: Unable to apply delta: %r" % (name, e))
 
 
 class cmd_dump_index(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
 
         if args == []:
             print("Usage: dulwich dump-index FILENAME")
             sys.exit(1)
 
         filename = args[0]
         idx = Index(filename)
 
         for o in idx:
             print(o, idx[o])
 
 
 class cmd_init(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["bare"])
         opts = dict(opts)
 
         if args == []:
             path = os.getcwd()
         else:
             path = args[0]
 
         porcelain.init(path, bare=("--bare" in opts))
 
 
 class cmd_clone(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "--bare",
             dest="bare",
             help="Whether to create a bare repository.",
             action="store_true",
         )
         parser.add_option(
             "--depth", dest="depth", type=int, help="Depth at which to fetch"
         )
         options, args = parser.parse_args(args)
 
         if args == []:
             print("usage: dulwich clone host:path [PATH]")
             sys.exit(1)
 
         source = args.pop(0)
         if len(args) > 0:
             target = args.pop(0)
         else:
             target = None
 
         porcelain.clone(source, target, bare=options.bare, depth=options.depth)
 
 
 class cmd_commit(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["message"])
         opts = dict(opts)
         porcelain.commit(".", message=opts["--message"])
 
 
 class cmd_commit_tree(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["message"])
         if args == []:
             print("usage: dulwich commit-tree tree")
             sys.exit(1)
         opts = dict(opts)
         porcelain.commit_tree(".", tree=args[0], message=opts["--message"])
 
 
 class cmd_update_server_info(Command):
     def run(self, args):
         porcelain.update_server_info(".")
 
 
 class cmd_symbolic_ref(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["ref-name", "force"])
         if not args:
             print("Usage: dulwich symbolic-ref REF_NAME [--force]")
             sys.exit(1)
 
         ref_name = args.pop(0)
         porcelain.symbolic_ref(".", ref_name=ref_name, force="--force" in args)
 
 
 class cmd_show(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         parser.add_argument('objectish', type=str, nargs='*')
         args = parser.parse_args(argv)
         porcelain.show(".", args.objectish or None)
 
 
 class cmd_diff_tree(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         if len(args) < 2:
             print("Usage: dulwich diff-tree OLD-TREE NEW-TREE")
             sys.exit(1)
         porcelain.diff_tree(".", args[0], args[1])
 
 
 class cmd_rev_list(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         if len(args) < 1:
             print("Usage: dulwich rev-list COMMITID...")
             sys.exit(1)
         porcelain.rev_list(".", args)
 
 
 class cmd_tag(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "-a",
             "--annotated",
             help="Create an annotated tag.",
             action="store_true",
         )
         parser.add_option(
             "-s", "--sign", help="Sign the annotated tag.", action="store_true"
         )
         options, args = parser.parse_args(args)
         porcelain.tag_create(
             ".", args[0], annotated=options.annotated, sign=options.sign
         )
 
 
 class cmd_repack(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         opts = dict(opts)
         porcelain.repack(".")
 
 
 class cmd_reset(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["hard", "soft", "mixed"])
         opts = dict(opts)
         mode = ""
         if "--hard" in opts:
             mode = "hard"
         elif "--soft" in opts:
             mode = "soft"
         elif "--mixed" in opts:
             mode = "mixed"
         porcelain.reset(".", mode=mode, *args)
 
 
 class cmd_daemon(Command):
     def run(self, args):
         from dulwich import log_utils
         from dulwich.protocol import TCP_GIT_PORT
 
         parser = optparse.OptionParser()
         parser.add_option(
             "-l",
             "--listen_address",
             dest="listen_address",
             default="localhost",
             help="Binding IP address.",
         )
         parser.add_option(
             "-p",
             "--port",
             dest="port",
             type=int,
             default=TCP_GIT_PORT,
             help="Binding TCP port.",
         )
         options, args = parser.parse_args(args)
 
         log_utils.default_logging_config()
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
 
         porcelain.daemon(gitdir, address=options.listen_address, port=options.port)
 
 
 class cmd_web_daemon(Command):
     def run(self, args):
         from dulwich import log_utils
 
         parser = optparse.OptionParser()
         parser.add_option(
             "-l",
             "--listen_address",
             dest="listen_address",
             default="",
             help="Binding IP address.",
         )
         parser.add_option(
             "-p",
             "--port",
             dest="port",
             type=int,
             default=8000,
             help="Binding TCP port.",
         )
         options, args = parser.parse_args(args)
 
         log_utils.default_logging_config()
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
 
         porcelain.web_daemon(gitdir, address=options.listen_address, port=options.port)
 
 
 class cmd_write_tree(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         sys.stdout.write("%s\n" % porcelain.write_tree("."))
 
 
 class cmd_receive_pack(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
         porcelain.receive_pack(gitdir)
 
 
 class cmd_upload_pack(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
         porcelain.upload_pack(gitdir)
 
 
 class cmd_status(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
         status = porcelain.status(gitdir)
         if any(names for (kind, names) in status.staged.items()):
             sys.stdout.write("Changes to be committed:\n\n")
             for kind, names in status.staged.items():
                 for name in names:
                     sys.stdout.write(
                         "\t%s: %s\n" % (kind, name.decode(sys.getfilesystemencoding()))
                     )
             sys.stdout.write("\n")
         if status.unstaged:
             sys.stdout.write("Changes not staged for commit:\n\n")
             for name in status.unstaged:
                 sys.stdout.write("\t%s\n" % name.decode(sys.getfilesystemencoding()))
             sys.stdout.write("\n")
         if status.untracked:
             sys.stdout.write("Untracked files:\n\n")
             for name in status.untracked:
                 sys.stdout.write("\t%s\n" % name)
             sys.stdout.write("\n")
 
 
 class cmd_ls_remote(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         if len(args) < 1:
             print("Usage: dulwich ls-remote URL")
             sys.exit(1)
         refs = porcelain.ls_remote(args[0])
         for ref in sorted(refs):
             sys.stdout.write("%s\t%s\n" % (ref, refs[ref]))
 
 
 class cmd_ls_tree(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "-r",
             "--recursive",
             action="store_true",
             help="Recusively list tree contents.",
         )
         parser.add_option("--name-only", action="store_true", help="Only display name.")
         options, args = parser.parse_args(args)
         try:
             treeish = args.pop(0)
         except IndexError:
             treeish = None
         porcelain.ls_tree(
             ".",
             treeish,
             outstream=sys.stdout,
             recursive=options.recursive,
             name_only=options.name_only,
         )
 
 
 class cmd_pack_objects(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["stdout"])
         opts = dict(opts)
         if len(args) < 1 and "--stdout" not in args:
             print("Usage: dulwich pack-objects basename")
             sys.exit(1)
         object_ids = [line.strip() for line in sys.stdin.readlines()]
         basename = args[0]
         if "--stdout" in opts:
             packf = getattr(sys.stdout, "buffer", sys.stdout)
             idxf = None
             close = []
         else:
             packf = open(basename + ".pack", "w")
             idxf = open(basename + ".idx", "w")
             close = [packf, idxf]
         porcelain.pack_objects(".", object_ids, packf, idxf)
         for f in close:
             f.close()
 
 
 class cmd_pull(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         try:
             from_location = args[0]
         except IndexError:
             from_location = None
         porcelain.pull(".", from_location)
 
 
 class cmd_push(Command):
 
     def run(self, argv):
         parser = argparse.ArgumentParser()
         parser.add_argument('to_location', type=str)
         parser.add_argument('refspec', type=str, nargs='*')
         args = parser.parse_args(argv)
         porcelain.push('.', args.to_location, args.refspec or None)
 
 
 class cmd_remote_add(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         porcelain.remote_add(".", args[0], args[1])
 
 
 class SuperCommand(Command):
 
     subcommands = {}  # type: Dict[str, Type[Command]]
 
     def run(self, args):
         if not args:
             print("Supported subcommands: %s" % ", ".join(self.subcommands.keys()))
             return False
         cmd = args[0]
         try:
             cmd_kls = self.subcommands[cmd]
         except KeyError:
             print("No such subcommand: %s" % args[0])
             return False
         return cmd_kls().run(args[1:])
 
 
 class cmd_remote(SuperCommand):
 
     subcommands = {
         "add": cmd_remote_add,
     }
 
 
 class cmd_check_ignore(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         ret = 1
         for path in porcelain.check_ignore(".", args):
             print(path)
             ret = 0
         return ret
 
 
 class cmd_check_mailmap(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         for arg in args:
             canonical_identity = porcelain.check_mailmap(".", arg)
             print(canonical_identity)
 
 
 class cmd_stash_list(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         for i, entry in porcelain.stash_list("."):
             print("stash@{%d}: %s" % (i, entry.message.rstrip("\n")))
 
 
 class cmd_stash_push(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         porcelain.stash_push(".")
         print("Saved working directory and index state")
 
 
 class cmd_stash_pop(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         porcelain.stash_pop(".")
         print("Restrored working directory and index state")
 
 
 class cmd_stash(SuperCommand):
 
     subcommands = {
         "list": cmd_stash_list,
         "pop": cmd_stash_pop,
         "push": cmd_stash_push,
     }
 
 
 class cmd_ls_files(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         for name in porcelain.ls_files("."):
             print(name)
 
 
 class cmd_describe(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         print(porcelain.describe("."))
 
 
 class cmd_help(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "-a",
             "--all",
             dest="all",
             action="store_true",
             help="List all commands.",
         )
         options, args = parser.parse_args(args)
 
         if options.all:
             print("Available commands:")
             for cmd in sorted(commands):
                 print("  %s" % cmd)
         else:
             print(
                 """\
 The dulwich command line tool is currently a very basic frontend for the
 Dulwich python module. For full functionality, please see the API reference.
 
 For a list of supported commands, see 'dulwich help -a'.
 """
             )
 
 
 commands = {
     "add": cmd_add,
     "archive": cmd_archive,
     "check-ignore": cmd_check_ignore,
     "check-mailmap": cmd_check_mailmap,
     "clone": cmd_clone,
     "commit": cmd_commit,
     "commit-tree": cmd_commit_tree,
     "describe": cmd_describe,
     "daemon": cmd_daemon,
     "diff": cmd_diff,
     "diff-tree": cmd_diff_tree,
     "dump-pack": cmd_dump_pack,
     "dump-index": cmd_dump_index,
     "fetch-pack": cmd_fetch_pack,
     "fetch": cmd_fetch,
     "fsck": cmd_fsck,
     "help": cmd_help,
     "init": cmd_init,
     "log": cmd_log,
     "ls-files": cmd_ls_files,
     "ls-remote": cmd_ls_remote,
     "ls-tree": cmd_ls_tree,
     "pack-objects": cmd_pack_objects,
     "pull": cmd_pull,
     "push": cmd_push,
     "receive-pack": cmd_receive_pack,
     "remote": cmd_remote,
     "repack": cmd_repack,
     "reset": cmd_reset,
     "rev-list": cmd_rev_list,
     "rm": cmd_rm,
     "show": cmd_show,
     "stash": cmd_stash,
     "status": cmd_status,
     "symbolic-ref": cmd_symbolic_ref,
     "tag": cmd_tag,
     "update-server-info": cmd_update_server_info,
     "upload-pack": cmd_upload_pack,
     "web-daemon": cmd_web_daemon,
     "write-tree": cmd_write_tree,
 }
 
 
 def main(argv=None):
     if argv is None:
-        argv = sys.argv
+        argv = sys.argv[1:]
 
     if len(argv) < 1:
         print("Usage: dulwich <%s> [OPTIONS...]" % ("|".join(commands.keys())))
         return 1
 
     cmd = argv[0]
     try:
         cmd_kls = commands[cmd]
     except KeyError:
         print("No such subcommand: %s" % cmd)
         return 1
     # TODO(jelmer): Return non-0 on errors
     return cmd_kls().run(argv[1:])
 
 
-if __name__ == "__main__":
+def _main():
     if "DULWICH_PDB" in os.environ and getattr(signal, "SIGQUIT", None):
         signal.signal(signal.SIGQUIT, signal_quit)  # type: ignore
     signal.signal(signal.SIGINT, signal_int)
 
-    sys.exit(main(sys.argv[1:]))
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    _main()
diff --git a/dulwich/client.py b/dulwich/client.py
index 8cc1f40c..2527853c 100644
--- a/dulwich/client.py
+++ b/dulwich/client.py
@@ -1,2200 +1,2238 @@
 # client.py -- Implementation of the client side git protocols
 # Copyright (C) 2008-2013 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.
 #
 
 """Client side support for the Git protocol.
 
 The Dulwich client supports the following capabilities:
 
  * thin-pack
  * multi_ack_detailed
  * multi_ack
  * side-band-64k
  * ofs-delta
  * quiet
  * report-status
  * delete-refs
  * shallow
 
 Known capabilities that are not supported:
 
  * no-progress
  * include-tag
 """
 
 from contextlib import closing
 from io import BytesIO, BufferedReader
 import logging
 import os
 import select
 import socket
 import subprocess
 import sys
 from typing import Optional, Dict, Callable, Set
 
 from urllib.parse import (
     quote as urlquote,
     unquote as urlunquote,
     urlparse,
     urljoin,
     urlunsplit,
     urlunparse,
 )
 
 import dulwich
 from dulwich.config import get_xdg_config_home_path
 from dulwich.errors import (
     GitProtocolError,
     NotGitRepository,
     SendPackError,
 )
 from dulwich.protocol import (
     HangupException,
     _RBUFSIZE,
     agent_string,
     capability_agent,
     extract_capability_names,
     CAPABILITY_AGENT,
     CAPABILITY_DELETE_REFS,
     CAPABILITY_INCLUDE_TAG,
     CAPABILITY_MULTI_ACK,
     CAPABILITY_MULTI_ACK_DETAILED,
     CAPABILITY_OFS_DELTA,
     CAPABILITY_QUIET,
     CAPABILITY_REPORT_STATUS,
     CAPABILITY_SHALLOW,
     CAPABILITY_SYMREF,
     CAPABILITY_SIDE_BAND_64K,
     CAPABILITY_THIN_PACK,
     CAPABILITIES_REF,
     KNOWN_RECEIVE_CAPABILITIES,
     KNOWN_UPLOAD_CAPABILITIES,
     COMMAND_DEEPEN,
     COMMAND_SHALLOW,
     COMMAND_UNSHALLOW,
     COMMAND_DONE,
     COMMAND_HAVE,
     COMMAND_WANT,
     SIDE_BAND_CHANNEL_DATA,
     SIDE_BAND_CHANNEL_PROGRESS,
     SIDE_BAND_CHANNEL_FATAL,
     PktLineParser,
     Protocol,
     ProtocolFile,
     TCP_GIT_PORT,
     ZERO_SHA,
     extract_capabilities,
     parse_capability,
 )
 from dulwich.pack import (
     write_pack_data,
     write_pack_objects,
 )
 from dulwich.refs import (
     read_info_refs,
     ANNOTATED_TAG_SUFFIX,
 )
 
 
 logger = logging.getLogger(__name__)
 
 
 class InvalidWants(Exception):
     """Invalid wants."""
 
     def __init__(self, wants):
         Exception.__init__(
             self, "requested wants not in server provided refs: %r" % wants
         )
 
 
 class HTTPUnauthorized(Exception):
     """Raised when authentication fails."""
 
     def __init__(self, www_authenticate, url):
         Exception.__init__(self, "No valid credentials provided")
         self.www_authenticate = www_authenticate
         self.url = url
 
 
+class HTTPProxyUnauthorized(Exception):
+    """Raised when proxy authentication fails."""
+
+    def __init__(self, proxy_authenticate, url):
+        Exception.__init__(self, "No valid proxy credentials provided")
+        self.proxy_authenticate = proxy_authenticate
+        self.url = url
+
+
 def _fileno_can_read(fileno):
     """Check if a file descriptor is readable."""
     return len(select.select([fileno], [], [], 0)[0]) > 0
 
 
 def _win32_peek_avail(handle):
     """Wrapper around PeekNamedPipe to check how many bytes are available."""
     from ctypes import byref, wintypes, windll
 
     c_avail = wintypes.DWORD()
     c_message = wintypes.DWORD()
     success = windll.kernel32.PeekNamedPipe(
         handle, None, 0, None, byref(c_avail), byref(c_message)
     )
     if not success:
         raise OSError(wintypes.GetLastError())
     return c_avail.value
 
 
 COMMON_CAPABILITIES = [CAPABILITY_OFS_DELTA, CAPABILITY_SIDE_BAND_64K]
 UPLOAD_CAPABILITIES = [
     CAPABILITY_THIN_PACK,
     CAPABILITY_MULTI_ACK,
     CAPABILITY_MULTI_ACK_DETAILED,
     CAPABILITY_SHALLOW,
 ] + COMMON_CAPABILITIES
 RECEIVE_CAPABILITIES = [
     CAPABILITY_REPORT_STATUS,
     CAPABILITY_DELETE_REFS,
 ] + COMMON_CAPABILITIES
 
 
 class ReportStatusParser(object):
     """Handle status as reported by servers with 'report-status' capability."""
 
     def __init__(self):
         self._done = False
         self._pack_status = None
         self._ref_statuses = []
 
     def check(self):
         """Check if there were any errors and, if so, raise exceptions.
 
         Raises:
           SendPackError: Raised when the server could not unpack
         Returns:
           iterator over refs
         """
         if self._pack_status not in (b"unpack ok", None):
             raise SendPackError(self._pack_status)
         for status in self._ref_statuses:
             try:
                 status, rest = status.split(b" ", 1)
             except ValueError:
                 # malformed response, move on to the next one
                 continue
             if status == b"ng":
                 ref, error = rest.split(b" ", 1)
                 yield ref, error.decode("utf-8")
             elif status == b"ok":
                 yield rest, None
             else:
                 raise GitProtocolError("invalid ref status %r" % status)
 
     def handle_packet(self, pkt):
         """Handle a packet.
 
         Raises:
           GitProtocolError: Raised when packets are received after a flush
           packet.
         """
         if self._done:
             raise GitProtocolError("received more data after status report")
         if pkt is None:
             self._done = True
             return
         if self._pack_status is None:
             self._pack_status = pkt.strip()
         else:
             ref_status = pkt.strip()
             self._ref_statuses.append(ref_status)
 
 
 def read_pkt_refs(proto):
     server_capabilities = None
     refs = {}
     # Receive refs from server
     for pkt in proto.read_pkt_seq():
         (sha, ref) = pkt.rstrip(b"\n").split(None, 1)
         if sha == b"ERR":
             raise GitProtocolError(ref.decode("utf-8", "replace"))
         if server_capabilities is None:
             (ref, server_capabilities) = extract_capabilities(ref)
         refs[ref] = sha
 
     if len(refs) == 0:
         return {}, set([])
     if refs == {CAPABILITIES_REF: ZERO_SHA}:
         refs = {}
     return refs, set(server_capabilities)
 
 
 class FetchPackResult(object):
     """Result of a fetch-pack operation.
 
     Attributes:
       refs: Dictionary with all remote refs
       symrefs: Dictionary with remote symrefs
       agent: User agent string
     """
 
     _FORWARDED_ATTRS = [
         "clear",
         "copy",
         "fromkeys",
         "get",
         "items",
         "keys",
         "pop",
         "popitem",
         "setdefault",
         "update",
         "values",
         "viewitems",
         "viewkeys",
         "viewvalues",
     ]
 
     def __init__(self, refs, symrefs, agent, new_shallow=None, new_unshallow=None):
         self.refs = refs
         self.symrefs = symrefs
         self.agent = agent
         self.new_shallow = new_shallow
         self.new_unshallow = new_unshallow
 
     def _warn_deprecated(self):
         import warnings
 
         warnings.warn(
             "Use FetchPackResult.refs instead.",
             DeprecationWarning,
             stacklevel=3,
         )
 
     def __eq__(self, other):
         if isinstance(other, dict):
             self._warn_deprecated()
             return self.refs == other
         return (
             self.refs == other.refs
             and self.symrefs == other.symrefs
             and self.agent == other.agent
         )
 
     def __contains__(self, name):
         self._warn_deprecated()
         return name in self.refs
 
     def __getitem__(self, name):
         self._warn_deprecated()
         return self.refs[name]
 
     def __len__(self):
         self._warn_deprecated()
         return len(self.refs)
 
     def __iter__(self):
         self._warn_deprecated()
         return iter(self.refs)
 
     def __getattribute__(self, name):
         if name in type(self)._FORWARDED_ATTRS:
             self._warn_deprecated()
             return getattr(self.refs, name)
         return super(FetchPackResult, self).__getattribute__(name)
 
     def __repr__(self):
         return "%s(%r, %r, %r)" % (
             self.__class__.__name__,
             self.refs,
             self.symrefs,
             self.agent,
         )
 
 
 class SendPackResult(object):
     """Result of a upload-pack operation.
 
     Attributes:
       refs: Dictionary with all remote refs
       agent: User agent string
       ref_status: Optional dictionary mapping ref name to error message (if it
         failed to update), or None if it was updated successfully
     """
 
     _FORWARDED_ATTRS = [
         "clear",
         "copy",
         "fromkeys",
         "get",
         "items",
         "keys",
         "pop",
         "popitem",
         "setdefault",
         "update",
         "values",
         "viewitems",
         "viewkeys",
         "viewvalues",
     ]
 
     def __init__(self, refs, agent=None, ref_status=None):
         self.refs = refs
         self.agent = agent
         self.ref_status = ref_status
 
     def _warn_deprecated(self):
         import warnings
 
         warnings.warn(
             "Use SendPackResult.refs instead.",
             DeprecationWarning,
             stacklevel=3,
         )
 
     def __eq__(self, other):
         if isinstance(other, dict):
             self._warn_deprecated()
             return self.refs == other
         return self.refs == other.refs and self.agent == other.agent
 
     def __contains__(self, name):
         self._warn_deprecated()
         return name in self.refs
 
     def __getitem__(self, name):
         self._warn_deprecated()
         return self.refs[name]
 
     def __len__(self):
         self._warn_deprecated()
         return len(self.refs)
 
     def __iter__(self):
         self._warn_deprecated()
         return iter(self.refs)
 
     def __getattribute__(self, name):
         if name in type(self)._FORWARDED_ATTRS:
             self._warn_deprecated()
             return getattr(self.refs, name)
         return super(SendPackResult, self).__getattribute__(name)
 
     def __repr__(self):
         return "%s(%r, %r)" % (self.__class__.__name__, self.refs, self.agent)
 
 
 def _read_shallow_updates(proto):
     new_shallow = set()
     new_unshallow = set()
     for pkt in proto.read_pkt_seq():
         cmd, sha = pkt.split(b" ", 1)
         if cmd == COMMAND_SHALLOW:
             new_shallow.add(sha.strip())
         elif cmd == COMMAND_UNSHALLOW:
             new_unshallow.add(sha.strip())
         else:
             raise GitProtocolError("unknown command %s" % pkt)
     return (new_shallow, new_unshallow)
 
 
 # TODO(durin42): this doesn't correctly degrade if the server doesn't
 # support some capabilities. This should work properly with servers
 # that don't support multi_ack.
 class GitClient(object):
     """Git smart server client."""
 
     def __init__(
         self,
         thin_packs=True,
         report_activity=None,
         quiet=False,
         include_tags=False,
     ):
         """Create a new GitClient instance.
 
         Args:
           thin_packs: Whether or not thin packs should be retrieved
           report_activity: Optional callback for reporting transport
             activity.
           include_tags: send annotated tags when sending the objects they point
             to
         """
         self._report_activity = report_activity
         self._report_status_parser = None
         self._fetch_capabilities = set(UPLOAD_CAPABILITIES)
         self._fetch_capabilities.add(capability_agent())
         self._send_capabilities = set(RECEIVE_CAPABILITIES)
         self._send_capabilities.add(capability_agent())
         if quiet:
             self._send_capabilities.add(CAPABILITY_QUIET)
         if not thin_packs:
             self._fetch_capabilities.remove(CAPABILITY_THIN_PACK)
         if include_tags:
             self._fetch_capabilities.add(CAPABILITY_INCLUDE_TAG)
 
     def get_url(self, path):
         """Retrieves full url to given path.
 
         Args:
           path: Repository path (as string)
 
         Returns:
           Url to path (as string)
 
         """
         raise NotImplementedError(self.get_url)
 
     @classmethod
     def from_parsedurl(cls, parsedurl, **kwargs):
         """Create an instance of this client from a urlparse.parsed object.
 
         Args:
           parsedurl: Result of urlparse()
 
         Returns:
           A `GitClient` object
         """
         raise NotImplementedError(cls.from_parsedurl)
 
     def send_pack(self, path, update_refs, generate_pack_data, progress=None):
         """Upload a pack to a remote repository.
 
         Args:
           path: Repository path (as bytestring)
           update_refs: Function to determine changes to remote refs. Receive
             dict with existing remote refs, returns dict with
             changed refs (name -> sha, where sha=ZERO_SHA for deletions)
           generate_pack_data: Function that can return a tuple
             with number of objects and list of pack data to include
           progress: Optional progress function
 
         Returns:
           SendPackResult object
 
         Raises:
           SendPackError: if server rejects the pack data
 
         """
         raise NotImplementedError(self.send_pack)
 
     def fetch(self, path, target, determine_wants=None, progress=None, depth=None):
         """Fetch into a target repository.
 
         Args:
           path: Path to fetch from (as bytestring)
           target: Target repository to fetch into
           determine_wants: Optional function to determine what refs to fetch.
             Receives dictionary of name->sha, should return
             list of shas to fetch. Defaults to all shas.
           progress: Optional progress function
           depth: Depth to fetch at
 
         Returns:
           Dictionary with all remote refs (not just those fetched)
 
         """
         if determine_wants is None:
             determine_wants = target.object_store.determine_wants_all
         if CAPABILITY_THIN_PACK in self._fetch_capabilities:
             # TODO(jelmer): Avoid reading entire file into memory and
             # only processing it after the whole file has been fetched.
             f = BytesIO()
 
             def commit():
                 if f.tell():
                     f.seek(0)
                     target.object_store.add_thin_pack(f.read, None)
 
             def abort():
                 pass
 
         else:
             f, commit, abort = target.object_store.add_pack()
         try:
             result = self.fetch_pack(
                 path,
                 determine_wants,
                 target.get_graph_walker(),
                 f.write,
                 progress=progress,
                 depth=depth,
             )
         except BaseException:
             abort()
             raise
         else:
             commit()
         target.update_shallow(result.new_shallow, result.new_unshallow)
         return result
 
     def fetch_pack(
         self,
         path,
         determine_wants,
         graph_walker,
         pack_data,
         progress=None,
         depth=None,
     ):
         """Retrieve a pack from a git smart server.
 
         Args:
           path: Remote path to fetch from
           determine_wants: Function determine what refs
-        to fetch. Receives dictionary of name->sha, should return
-        list of shas to fetch.
+            to fetch. Receives dictionary of name->sha, should return
+            list of shas to fetch.
           graph_walker: Object with next() and ack().
           pack_data: Callback called for each bit of data in the pack
           progress: Callback for progress reports (strings)
           depth: Shallow fetch depth
 
         Returns:
           FetchPackResult object
 
         """
         raise NotImplementedError(self.fetch_pack)
 
     def get_refs(self, path):
         """Retrieve the current refs from a git smart server.
 
         Args:
           path: Path to the repo to fetch from. (as bytestring)
 
         Returns:
 
         """
         raise NotImplementedError(self.get_refs)
 
     def _read_side_band64k_data(self, proto, channel_callbacks):
         """Read per-channel data.
 
         This requires the side-band-64k capability.
 
         Args:
           proto: Protocol object to read from
           channel_callbacks: Dictionary mapping channels to packet
             handlers to use. None for a callback discards channel data.
         """
         for pkt in proto.read_pkt_seq():
             channel = ord(pkt[:1])
             pkt = pkt[1:]
             try:
                 cb = channel_callbacks[channel]
             except KeyError:
                 raise AssertionError("Invalid sideband channel %d" % channel)
             else:
                 if cb is not None:
                     cb(pkt)
 
     @staticmethod
     def _should_send_pack(new_refs):
         # The packfile MUST NOT be sent if the only command used is delete.
         return any(sha != ZERO_SHA for sha in new_refs.values())
 
     def _handle_receive_pack_head(self, proto, capabilities, old_refs, new_refs):
         """Handle the head of a 'git-receive-pack' request.
 
         Args:
           proto: Protocol object to read from
           capabilities: List of negotiated capabilities
           old_refs: Old refs, as received from the server
           new_refs: Refs to change
 
         Returns:
           (have, want) tuple
         """
         want = []
         have = [x for x in old_refs.values() if not x == ZERO_SHA]
         sent_capabilities = False
 
         for refname in new_refs:
             if not isinstance(refname, bytes):
                 raise TypeError("refname is not a bytestring: %r" % refname)
             old_sha1 = old_refs.get(refname, ZERO_SHA)
             if not isinstance(old_sha1, bytes):
                 raise TypeError(
                     "old sha1 for %s is not a bytestring: %r" % (refname, old_sha1)
                 )
             new_sha1 = new_refs.get(refname, ZERO_SHA)
             if not isinstance(new_sha1, bytes):
                 raise TypeError(
                     "old sha1 for %s is not a bytestring %r" % (refname, new_sha1)
                 )
 
             if old_sha1 != new_sha1:
                 logger.debug(
                     'Sending updated ref %r: %r -> %r',
                     refname, old_sha1, new_sha1)
                 if sent_capabilities:
                     proto.write_pkt_line(old_sha1 + b" " + new_sha1 + b" " + refname)
                 else:
                     proto.write_pkt_line(
                         old_sha1
                         + b" "
                         + new_sha1
                         + b" "
                         + refname
                         + b"\0"
                         + b" ".join(sorted(capabilities))
                     )
                     sent_capabilities = True
             if new_sha1 not in have and new_sha1 != ZERO_SHA:
                 want.append(new_sha1)
         proto.write_pkt_line(None)
         return (have, want)
 
     def _negotiate_receive_pack_capabilities(self, server_capabilities):
         negotiated_capabilities = self._send_capabilities & server_capabilities
         agent = None
         for capability in server_capabilities:
             k, v = parse_capability(capability)
             if k == CAPABILITY_AGENT:
                 agent = v
         unknown_capabilities = (  # noqa: F841
             extract_capability_names(server_capabilities) - KNOWN_RECEIVE_CAPABILITIES
         )
         # TODO(jelmer): warn about unknown capabilities
         return negotiated_capabilities, agent
 
     def _handle_receive_pack_tail(
         self,
         proto: Protocol,
         capabilities: Set[bytes],
         progress: Callable[[bytes], None] = None,
     ) -> Optional[Dict[bytes, Optional[str]]]:
         """Handle the tail of a 'git-receive-pack' request.
 
         Args:
           proto: Protocol object to read from
           capabilities: List of negotiated capabilities
           progress: Optional progress reporting function
 
         Returns:
           dict mapping ref name to:
             error message if the ref failed to update
             None if it was updated successfully
         """
         if CAPABILITY_SIDE_BAND_64K in capabilities:
             if progress is None:
 
                 def progress(x):
                     pass
 
             channel_callbacks = {2: progress}
             if CAPABILITY_REPORT_STATUS in capabilities:
                 channel_callbacks[1] = PktLineParser(
                     self._report_status_parser.handle_packet
                 ).parse
             self._read_side_band64k_data(proto, channel_callbacks)
         else:
             if CAPABILITY_REPORT_STATUS in capabilities:
                 for pkt in proto.read_pkt_seq():
                     self._report_status_parser.handle_packet(pkt)
         if self._report_status_parser is not None:
             return dict(self._report_status_parser.check())
 
         return None
 
     def _negotiate_upload_pack_capabilities(self, server_capabilities):
         unknown_capabilities = (  # noqa: F841
             extract_capability_names(server_capabilities) - KNOWN_UPLOAD_CAPABILITIES
         )
         # TODO(jelmer): warn about unknown capabilities
         symrefs = {}
         agent = None
         for capability in server_capabilities:
             k, v = parse_capability(capability)
             if k == CAPABILITY_SYMREF:
                 (src, dst) = v.split(b":", 1)
                 symrefs[src] = dst
             if k == CAPABILITY_AGENT:
                 agent = v
 
         negotiated_capabilities = self._fetch_capabilities & server_capabilities
         return (negotiated_capabilities, symrefs, agent)
 
     def _handle_upload_pack_head(
         self, proto, capabilities, graph_walker, wants, can_read, depth
     ):
         """Handle the head of a 'git-upload-pack' request.
 
         Args:
           proto: Protocol object to read from
           capabilities: List of negotiated capabilities
           graph_walker: GraphWalker instance to call .ack() on
           wants: List of commits to fetch
           can_read: function that returns a boolean that indicates
         whether there is extra graph data to read on proto
           depth: Depth for request
 
         Returns:
 
         """
         assert isinstance(wants, list) and isinstance(wants[0], bytes)
         proto.write_pkt_line(
             COMMAND_WANT
             + b" "
             + wants[0]
             + b" "
             + b" ".join(sorted(capabilities))
             + b"\n"
         )
         for want in wants[1:]:
             proto.write_pkt_line(COMMAND_WANT + b" " + want + b"\n")
         if depth not in (0, None) or getattr(graph_walker, "shallow", None):
             if CAPABILITY_SHALLOW not in capabilities:
                 raise GitProtocolError(
                     "server does not support shallow capability required for " "depth"
                 )
             for sha in graph_walker.shallow:
                 proto.write_pkt_line(COMMAND_SHALLOW + b" " + sha + b"\n")
             if depth is not None:
                 proto.write_pkt_line(
                     COMMAND_DEEPEN + b" " + str(depth).encode("ascii") + b"\n"
                 )
             proto.write_pkt_line(None)
             if can_read is not None:
                 (new_shallow, new_unshallow) = _read_shallow_updates(proto)
             else:
                 new_shallow = new_unshallow = None
         else:
             new_shallow = new_unshallow = set()
             proto.write_pkt_line(None)
         have = next(graph_walker)
         while have:
             proto.write_pkt_line(COMMAND_HAVE + b" " + have + b"\n")
             if can_read is not None and can_read():
                 pkt = proto.read_pkt_line()
                 parts = pkt.rstrip(b"\n").split(b" ")
                 if parts[0] == b"ACK":
                     graph_walker.ack(parts[1])
                     if parts[2] in (b"continue", b"common"):
                         pass
                     elif parts[2] == b"ready":
                         break
                     else:
                         raise AssertionError(
                             "%s not in ('continue', 'ready', 'common)" % parts[2]
                         )
             have = next(graph_walker)
         proto.write_pkt_line(COMMAND_DONE + b"\n")
         return (new_shallow, new_unshallow)
 
     def _handle_upload_pack_tail(
         self,
         proto,
         capabilities,
         graph_walker,
         pack_data,
         progress=None,
         rbufsize=_RBUFSIZE,
     ):
         """Handle the tail of a 'git-upload-pack' request.
 
         Args:
           proto: Protocol object to read from
           capabilities: List of negotiated capabilities
           graph_walker: GraphWalker instance to call .ack() on
           pack_data: Function to call with pack data
           progress: Optional progress reporting function
           rbufsize: Read buffer size
 
         Returns:
 
         """
         pkt = proto.read_pkt_line()
         while pkt:
             parts = pkt.rstrip(b"\n").split(b" ")
             if parts[0] == b"ACK":
                 graph_walker.ack(parts[1])
             if len(parts) < 3 or parts[2] not in (
                 b"ready",
                 b"continue",
                 b"common",
             ):
                 break
             pkt = proto.read_pkt_line()
         if CAPABILITY_SIDE_BAND_64K in capabilities:
             if progress is None:
                 # Just ignore progress data
 
                 def progress(x):
                     pass
 
             self._read_side_band64k_data(
                 proto,
                 {
                     SIDE_BAND_CHANNEL_DATA: pack_data,
                     SIDE_BAND_CHANNEL_PROGRESS: progress,
                 },
             )
         else:
             while True:
                 data = proto.read(rbufsize)
                 if data == b"":
                     break
                 pack_data(data)
 
 
 def check_wants(wants, refs):
     """Check that a set of wants is valid.
 
     Args:
       wants: Set of object SHAs to fetch
       refs: Refs dictionary to check against
 
     Returns:
 
     """
     missing = set(wants) - {
         v for (k, v) in refs.items() if not k.endswith(ANNOTATED_TAG_SUFFIX)
     }
     if missing:
         raise InvalidWants(missing)
 
 
 def _remote_error_from_stderr(stderr):
     if stderr is None:
         return HangupException()
     lines = [line.rstrip(b"\n") for line in stderr.readlines()]
     for line in lines:
         if line.startswith(b"ERROR: "):
             return GitProtocolError(line[len(b"ERROR: ") :].decode("utf-8", "replace"))
     return HangupException(lines)
 
 
 class TraditionalGitClient(GitClient):
     """Traditional Git client."""
 
     DEFAULT_ENCODING = "utf-8"
 
     def __init__(self, path_encoding=DEFAULT_ENCODING, **kwargs):
         self._remote_path_encoding = path_encoding
         super(TraditionalGitClient, self).__init__(**kwargs)
 
     async def _connect(self, cmd, path):
         """Create a connection to the server.
 
         This method is abstract - concrete implementations should
         implement their own variant which connects to the server and
         returns an initialized Protocol object with the service ready
         for use and a can_read function which may be used to see if
         reads would block.
 
         Args:
           cmd: The git service name to which we should connect.
           path: The path we should pass to the service. (as bytestirng)
         """
         raise NotImplementedError()
 
     def send_pack(self, path, update_refs, generate_pack_data, progress=None):
         """Upload a pack to a remote repository.
 
         Args:
           path: Repository path (as bytestring)
           update_refs: Function to determine changes to remote refs.
-        Receive dict with existing remote refs, returns dict with
-        changed refs (name -> sha, where sha=ZERO_SHA for deletions)
+            Receive dict with existing remote refs, returns dict with
+            changed refs (name -> sha, where sha=ZERO_SHA for deletions)
           generate_pack_data: Function that can return a tuple with
-        number of objects and pack data to upload.
+            number of objects and pack data to upload.
           progress: Optional callback called with progress updates
 
         Returns:
           SendPackResult
 
         Raises:
           SendPackError: if server rejects the pack data
 
         """
         proto, unused_can_read, stderr = self._connect(b"receive-pack", path)
         with proto:
             try:
                 old_refs, server_capabilities = read_pkt_refs(proto)
             except HangupException:
                 raise _remote_error_from_stderr(stderr)
             (
                 negotiated_capabilities,
                 agent,
             ) = self._negotiate_receive_pack_capabilities(server_capabilities)
             if CAPABILITY_REPORT_STATUS in negotiated_capabilities:
                 self._report_status_parser = ReportStatusParser()
             report_status_parser = self._report_status_parser
 
             try:
                 new_refs = orig_new_refs = update_refs(dict(old_refs))
             except BaseException:
                 proto.write_pkt_line(None)
                 raise
 
             if set(new_refs.items()).issubset(set(old_refs.items())):
                 proto.write_pkt_line(None)
                 return SendPackResult(new_refs, agent=agent, ref_status={})
 
             if CAPABILITY_DELETE_REFS not in server_capabilities:
                 # Server does not support deletions. Fail later.
                 new_refs = dict(orig_new_refs)
                 for ref, sha in orig_new_refs.items():
                     if sha == ZERO_SHA:
                         if CAPABILITY_REPORT_STATUS in negotiated_capabilities:
                             report_status_parser._ref_statuses.append(
                                 b"ng " + ref + b" remote does not support deleting refs"
                             )
                             report_status_parser._ref_status_ok = False
                         del new_refs[ref]
 
             if new_refs is None:
                 proto.write_pkt_line(None)
                 return SendPackResult(old_refs, agent=agent, ref_status={})
 
             if len(new_refs) == 0 and orig_new_refs:
                 # NOOP - Original new refs filtered out by policy
                 proto.write_pkt_line(None)
                 if report_status_parser is not None:
                     ref_status = dict(report_status_parser.check())
                 else:
                     ref_status = None
                 return SendPackResult(old_refs, agent=agent, ref_status=ref_status)
 
             (have, want) = self._handle_receive_pack_head(
                 proto, negotiated_capabilities, old_refs, new_refs
             )
 
             pack_data_count, pack_data = generate_pack_data(
                 have,
                 want,
                 ofs_delta=(CAPABILITY_OFS_DELTA in negotiated_capabilities),
             )
 
             if self._should_send_pack(new_refs):
                 write_pack_data(proto.write_file(), pack_data_count, pack_data)
 
             ref_status = self._handle_receive_pack_tail(
                 proto, negotiated_capabilities, progress
             )
             return SendPackResult(new_refs, agent=agent, ref_status=ref_status)
 
     def fetch_pack(
         self,
         path,
         determine_wants,
         graph_walker,
         pack_data,
         progress=None,
         depth=None,
     ):
         """Retrieve a pack from a git smart server.
 
         Args:
           path: Remote path to fetch from
           determine_wants: Function determine what refs
-        to fetch. Receives dictionary of name->sha, should return
-        list of shas to fetch.
+            to fetch. Receives dictionary of name->sha, should return
+            list of shas to fetch.
           graph_walker: Object with next() and ack().
           pack_data: Callback called for each bit of data in the pack
           progress: Callback for progress reports (strings)
           depth: Shallow fetch depth
 
         Returns:
           FetchPackResult object
 
         """
         proto, can_read, stderr = self._connect(b"upload-pack", path)
         with proto:
             try:
                 refs, server_capabilities = read_pkt_refs(proto)
             except HangupException:
                 raise _remote_error_from_stderr(stderr)
             (
                 negotiated_capabilities,
                 symrefs,
                 agent,
             ) = self._negotiate_upload_pack_capabilities(server_capabilities)
 
             if refs is None:
                 proto.write_pkt_line(None)
                 return FetchPackResult(refs, symrefs, agent)
 
             try:
                 if depth is not None:
                     wants = determine_wants(refs, depth=depth)
                 else:
                     wants = determine_wants(refs)
             except BaseException:
                 proto.write_pkt_line(None)
                 raise
             if wants is not None:
                 wants = [cid for cid in wants if cid != ZERO_SHA]
             if not wants:
                 proto.write_pkt_line(None)
                 return FetchPackResult(refs, symrefs, agent)
             (new_shallow, new_unshallow) = self._handle_upload_pack_head(
                 proto,
                 negotiated_capabilities,
                 graph_walker,
                 wants,
                 can_read,
                 depth=depth,
             )
             self._handle_upload_pack_tail(
                 proto,
                 negotiated_capabilities,
                 graph_walker,
                 pack_data,
                 progress,
             )
             return FetchPackResult(refs, symrefs, agent, new_shallow, new_unshallow)
 
     def get_refs(self, path):
         """Retrieve the current refs from a git smart server."""
         # stock `git ls-remote` uses upload-pack
         proto, _, stderr = self._connect(b"upload-pack", path)
         with proto:
             try:
                 refs, _ = read_pkt_refs(proto)
             except HangupException:
                 raise _remote_error_from_stderr(stderr)
             proto.write_pkt_line(None)
             return refs
 
     def archive(
         self,
         path,
         committish,
         write_data,
         progress=None,
         write_error=None,
         format=None,
         subdirs=None,
         prefix=None,
     ):
         proto, can_read, stderr = self._connect(b"upload-archive", path)
         with proto:
             if format is not None:
                 proto.write_pkt_line(b"argument --format=" + format)
             proto.write_pkt_line(b"argument " + committish)
             if subdirs is not None:
                 for subdir in subdirs:
                     proto.write_pkt_line(b"argument " + subdir)
             if prefix is not None:
                 proto.write_pkt_line(b"argument --prefix=" + prefix)
             proto.write_pkt_line(None)
             try:
                 pkt = proto.read_pkt_line()
             except HangupException:
                 raise _remote_error_from_stderr(stderr)
             if pkt == b"NACK\n" or pkt == b"NACK":
                 return
             elif pkt == b"ACK\n" or pkt == b"ACK":
                 pass
             elif pkt.startswith(b"ERR "):
                 raise GitProtocolError(pkt[4:].rstrip(b"\n").decode("utf-8", "replace"))
             else:
                 raise AssertionError("invalid response %r" % pkt)
             ret = proto.read_pkt_line()
             if ret is not None:
                 raise AssertionError("expected pkt tail")
             self._read_side_band64k_data(
                 proto,
                 {
                     SIDE_BAND_CHANNEL_DATA: write_data,
                     SIDE_BAND_CHANNEL_PROGRESS: progress,
                     SIDE_BAND_CHANNEL_FATAL: write_error,
                 },
             )
 
 
 class TCPGitClient(TraditionalGitClient):
     """A Git Client that works over TCP directly (i.e. git://)."""
 
     def __init__(self, host, port=None, **kwargs):
         if port is None:
             port = TCP_GIT_PORT
         self._host = host
         self._port = port
         super(TCPGitClient, self).__init__(**kwargs)
 
     @classmethod
     def from_parsedurl(cls, parsedurl, **kwargs):
         return cls(parsedurl.hostname, port=parsedurl.port, **kwargs)
 
     def get_url(self, path):
         netloc = self._host
         if self._port is not None and self._port != TCP_GIT_PORT:
             netloc += ":%d" % self._port
         return urlunsplit(("git", netloc, path, "", ""))
 
     def _connect(self, cmd, path):
         if not isinstance(cmd, bytes):
             raise TypeError(cmd)
         if not isinstance(path, bytes):
             path = path.encode(self._remote_path_encoding)
         sockaddrs = socket.getaddrinfo(
             self._host, self._port, socket.AF_UNSPEC, socket.SOCK_STREAM
         )
         s = None
         err = socket.error("no address found for %s" % self._host)
         for (family, socktype, proto, canonname, sockaddr) in sockaddrs:
             s = socket.socket(family, socktype, proto)
             s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
             try:
                 s.connect(sockaddr)
                 break
             except socket.error as e:
                 err = e
                 if s is not None:
                     s.close()
                 s = None
         if s is None:
             raise err
         # -1 means system default buffering
         rfile = s.makefile("rb", -1)
         # 0 means unbuffered
         wfile = s.makefile("wb", 0)
 
         def close():
             rfile.close()
             wfile.close()
             s.close()
 
         proto = Protocol(
             rfile.read,
             wfile.write,
             close,
             report_activity=self._report_activity,
         )
         if path.startswith(b"/~"):
             path = path[1:]
         # TODO(jelmer): Alternative to ascii?
         proto.send_cmd(b"git-" + cmd, path, b"host=" + self._host.encode("ascii"))
         return proto, lambda: _fileno_can_read(s), None
 
 
 class SubprocessWrapper(object):
     """A socket-like object that talks to a subprocess via pipes."""
 
     def __init__(self, proc):
         self.proc = proc
         self.read = BufferedReader(proc.stdout).read
         self.write = proc.stdin.write
 
     @property
     def stderr(self):
         return self.proc.stderr
 
     def can_read(self):
         if sys.platform == "win32":
             from msvcrt import get_osfhandle
 
             handle = get_osfhandle(self.proc.stdout.fileno())
             return _win32_peek_avail(handle) != 0
         else:
             return _fileno_can_read(self.proc.stdout.fileno())
 
     def close(self):
         self.proc.stdin.close()
         self.proc.stdout.close()
         if self.proc.stderr:
             self.proc.stderr.close()
         self.proc.wait()
 
 
 def find_git_command():
     """Find command to run for system Git (usually C Git)."""
     if sys.platform == "win32":  # support .exe, .bat and .cmd
         try:  # to avoid overhead
             import win32api
         except ImportError:  # run through cmd.exe with some overhead
             return ["cmd", "/c", "git"]
         else:
             status, git = win32api.FindExecutable("git")
             return [git]
     else:
         return ["git"]
 
 
 class SubprocessGitClient(TraditionalGitClient):
     """Git client that talks to a server using a subprocess."""
 
     @classmethod
     def from_parsedurl(cls, parsedurl, **kwargs):
         return cls(**kwargs)
 
     git_command = None
 
     def _connect(self, service, path):
         if not isinstance(service, bytes):
             raise TypeError(service)
         if isinstance(path, bytes):
             path = path.decode(self._remote_path_encoding)
         if self.git_command is None:
             git_command = find_git_command()
         argv = git_command + [service.decode("ascii"), path]
         p = subprocess.Popen(
             argv,
             bufsize=0,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
         pw = SubprocessWrapper(p)
         return (
             Protocol(
                 pw.read,
                 pw.write,
                 pw.close,
                 report_activity=self._report_activity,
             ),
             pw.can_read,
             p.stderr,
         )
 
 
 class LocalGitClient(GitClient):
     """Git Client that just uses a local Repo."""
 
     def __init__(self, thin_packs=True, report_activity=None, config=None):
         """Create a new LocalGitClient instance.
 
         Args:
           thin_packs: Whether or not thin packs should be retrieved
           report_activity: Optional callback for reporting transport
             activity.
         """
         self._report_activity = report_activity
         # Ignore the thin_packs argument
 
     def get_url(self, path):
         return urlunsplit(("file", "", path, "", ""))
 
     @classmethod
     def from_parsedurl(cls, parsedurl, **kwargs):
         return cls(**kwargs)
 
     @classmethod
     def _open_repo(cls, path):
         from dulwich.repo import Repo
 
         if not isinstance(path, str):
             path = os.fsdecode(path)
         return closing(Repo(path))
 
     def send_pack(self, path, update_refs, generate_pack_data, progress=None):
         """Upload a pack to a remote repository.
 
         Args:
           path: Repository path (as bytestring)
           update_refs: Function to determine changes to remote refs.
-        Receive dict with existing remote refs, returns dict with
-        changed refs (name -> sha, where sha=ZERO_SHA for deletions)
-        with number of items and pack data to upload.
+            Receive dict with existing remote refs, returns dict with
+            changed refs (name -> sha, where sha=ZERO_SHA for deletions)
+            with number of items and pack data to upload.
           progress: Optional progress function
 
         Returns:
           SendPackResult
 
         Raises:
           SendPackError: if server rejects the pack data
 
         """
         if not progress:
 
             def progress(x):
                 pass
 
         with self._open_repo(path) as target:
             old_refs = target.get_refs()
             new_refs = update_refs(dict(old_refs))
 
             have = [sha1 for sha1 in old_refs.values() if sha1 != ZERO_SHA]
             want = []
             for refname, new_sha1 in new_refs.items():
                 if (
                     new_sha1 not in have
                     and new_sha1 not in want
                     and new_sha1 != ZERO_SHA
                 ):
                     want.append(new_sha1)
 
             if not want and set(new_refs.items()).issubset(set(old_refs.items())):
                 return SendPackResult(new_refs, ref_status={})
 
             target.object_store.add_pack_data(
                 *generate_pack_data(have, want, ofs_delta=True)
             )
 
             ref_status = {}
 
             for refname, new_sha1 in new_refs.items():
                 old_sha1 = old_refs.get(refname, ZERO_SHA)
                 if new_sha1 != ZERO_SHA:
                     if not target.refs.set_if_equals(refname, old_sha1, new_sha1):
                         msg = "unable to set %s to %s" % (refname, new_sha1)
                         progress(msg)
                         ref_status[refname] = msg
                 else:
                     if not target.refs.remove_if_equals(refname, old_sha1):
                         progress("unable to remove %s" % refname)
                         ref_status[refname] = "unable to remove"
 
         return SendPackResult(new_refs, ref_status=ref_status)
 
     def fetch(self, path, target, determine_wants=None, progress=None, depth=None):
         """Fetch into a target repository.
 
         Args:
           path: Path to fetch from (as bytestring)
           target: Target repository to fetch into
           determine_wants: Optional function determine what refs
-        to fetch. Receives dictionary of name->sha, should return
-        list of shas to fetch. Defaults to all shas.
+            to fetch. Receives dictionary of name->sha, should return
+            list of shas to fetch. Defaults to all shas.
           progress: Optional progress function
           depth: Shallow fetch depth
 
         Returns:
           FetchPackResult object
 
         """
         with self._open_repo(path) as r:
             refs = r.fetch(
                 target,
                 determine_wants=determine_wants,
                 progress=progress,
                 depth=depth,
             )
             return FetchPackResult(refs, r.refs.get_symrefs(), agent_string())
 
     def fetch_pack(
         self,
         path,
         determine_wants,
         graph_walker,
         pack_data,
         progress=None,
         depth=None,
     ):
         """Retrieve a pack from a git smart server.
 
         Args:
           path: Remote path to fetch from
           determine_wants: Function determine what refs
-        to fetch. Receives dictionary of name->sha, should return
-        list of shas to fetch.
+            to fetch. Receives dictionary of name->sha, should return
+            list of shas to fetch.
           graph_walker: Object with next() and ack().
           pack_data: Callback called for each bit of data in the pack
           progress: Callback for progress reports (strings)
           depth: Shallow fetch depth
 
         Returns:
           FetchPackResult object
 
         """
         with self._open_repo(path) as r:
             objects_iter = r.fetch_objects(
                 determine_wants, graph_walker, progress=progress, depth=depth
             )
             symrefs = r.refs.get_symrefs()
             agent = agent_string()
 
             # Did the process short-circuit (e.g. in a stateless RPC call)?
             # Note that the client still expects a 0-object pack in most cases.
             if objects_iter is None:
                 return FetchPackResult(None, symrefs, agent)
             protocol = ProtocolFile(None, pack_data)
             write_pack_objects(protocol, objects_iter)
             return FetchPackResult(r.get_refs(), symrefs, agent)
 
     def get_refs(self, path):
         """Retrieve the current refs from a git smart server."""
 
         with self._open_repo(path) as target:
             return target.get_refs()
 
 
 # What Git client to use for local access
 default_local_git_client_cls = LocalGitClient
 
 
 class SSHVendor(object):
     """A client side SSH implementation."""
 
     def connect_ssh(
         self,
         host,
         command,
         username=None,
         port=None,
         password=None,
         key_filename=None,
     ):
         # This function was deprecated in 0.9.1
         import warnings
 
         warnings.warn(
             "SSHVendor.connect_ssh has been renamed to SSHVendor.run_command",
             DeprecationWarning,
         )
         return self.run_command(
             host,
             command,
             username=username,
             port=port,
             password=password,
             key_filename=key_filename,
         )
 
     def run_command(
         self,
         host,
         command,
         username=None,
         port=None,
         password=None,
         key_filename=None,
     ):
         """Connect to an SSH server.
 
         Run a command remotely and return a file-like object for interaction
         with the remote command.
 
         Args:
           host: Host name
           command: Command to run (as argv array)
           username: Optional ame of user to log in as
           port: Optional SSH port to use
           password: Optional ssh password for login or private key
           key_filename: Optional path to private keyfile
 
         Returns:
 
         """
         raise NotImplementedError(self.run_command)
 
 
 class StrangeHostname(Exception):
     """Refusing to connect to strange SSH hostname."""
 
     def __init__(self, hostname):
         super(StrangeHostname, self).__init__(hostname)
 
 
 class SubprocessSSHVendor(SSHVendor):
     """SSH vendor that shells out to the local 'ssh' command."""
 
     def run_command(
         self,
         host,
         command,
         username=None,
         port=None,
         password=None,
         key_filename=None,
     ):
 
         if password is not None:
             raise NotImplementedError(
                 "Setting password not supported by SubprocessSSHVendor."
             )
 
         args = ["ssh", "-x"]
 
         if port:
             args.extend(["-p", str(port)])
 
         if key_filename:
             args.extend(["-i", str(key_filename)])
 
         if username:
             host = "%s@%s" % (username, host)
         if host.startswith("-"):
             raise StrangeHostname(hostname=host)
         args.append(host)
 
         proc = subprocess.Popen(
             args + [command],
             bufsize=0,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
         return SubprocessWrapper(proc)
 
 
 class PLinkSSHVendor(SSHVendor):
     """SSH vendor that shells out to the local 'plink' command."""
 
     def run_command(
         self,
         host,
         command,
         username=None,
         port=None,
         password=None,
         key_filename=None,
     ):
 
         if sys.platform == "win32":
             args = ["plink.exe", "-ssh"]
         else:
             args = ["plink", "-ssh"]
 
         if password is not None:
             import warnings
 
             warnings.warn(
                 "Invoking PLink with a password exposes the password in the "
                 "process list."
             )
             args.extend(["-pw", str(password)])
 
         if port:
             args.extend(["-P", str(port)])
 
         if key_filename:
             args.extend(["-i", str(key_filename)])
 
         if username:
             host = "%s@%s" % (username, host)
         if host.startswith("-"):
             raise StrangeHostname(hostname=host)
         args.append(host)
 
         proc = subprocess.Popen(
             args + [command],
             bufsize=0,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
         return SubprocessWrapper(proc)
 
 
 def ParamikoSSHVendor(**kwargs):
     import warnings
 
     warnings.warn(
         "ParamikoSSHVendor has been moved to dulwich.contrib.paramiko_vendor.",
         DeprecationWarning,
     )
     from dulwich.contrib.paramiko_vendor import ParamikoSSHVendor
 
     return ParamikoSSHVendor(**kwargs)
 
 
 # Can be overridden by users
 get_ssh_vendor = SubprocessSSHVendor
 
 
 class SSHGitClient(TraditionalGitClient):
     def __init__(
         self,
         host,
         port=None,
         username=None,
         vendor=None,
         config=None,
         password=None,
         key_filename=None,
         **kwargs
     ):
         self.host = host
         self.port = port
         self.username = username
         self.password = password
         self.key_filename = key_filename
         super(SSHGitClient, self).__init__(**kwargs)
         self.alternative_paths = {}
         if vendor is not None:
             self.ssh_vendor = vendor
         else:
             self.ssh_vendor = get_ssh_vendor()
 
     def get_url(self, path):
         netloc = self.host
         if self.port is not None:
             netloc += ":%d" % self.port
 
         if self.username is not None:
             netloc = urlquote(self.username, "@/:") + "@" + netloc
 
         return urlunsplit(("ssh", netloc, path, "", ""))
 
     @classmethod
     def from_parsedurl(cls, parsedurl, **kwargs):
         return cls(
             host=parsedurl.hostname,
             port=parsedurl.port,
             username=parsedurl.username,
             **kwargs
         )
 
     def _get_cmd_path(self, cmd):
         cmd = self.alternative_paths.get(cmd, b"git-" + cmd)
         assert isinstance(cmd, bytes)
         return cmd
 
     def _connect(self, cmd, path):
         if not isinstance(cmd, bytes):
             raise TypeError(cmd)
         if isinstance(path, bytes):
             path = path.decode(self._remote_path_encoding)
         if path.startswith("/~"):
             path = path[1:]
         argv = (
             self._get_cmd_path(cmd).decode(self._remote_path_encoding)
             + " '"
             + path
             + "'"
         )
         kwargs = {}
         if self.password is not None:
             kwargs["password"] = self.password
         if self.key_filename is not None:
             kwargs["key_filename"] = self.key_filename
         con = self.ssh_vendor.run_command(
             self.host, argv, port=self.port, username=self.username, **kwargs
         )
         return (
             Protocol(
                 con.read,
                 con.write,
                 con.close,
                 report_activity=self._report_activity,
             ),
             con.can_read,
             getattr(con, "stderr", None),
         )
 
 
 def default_user_agent_string():
     # Start user agent with "git/", because GitHub requires this. :-( See
     # https://github.com/jelmer/dulwich/issues/562 for details.
     return "git/dulwich/%s" % ".".join([str(x) for x in dulwich.__version__])
 
 
 def default_urllib3_manager(   # noqa: C901
     config, pool_manager_cls=None, proxy_manager_cls=None, **override_kwargs
 ):
     """Return `urllib3` connection pool manager.
 
     Honour detected proxy configurations.
 
     Args:
       config: dulwich.config.ConfigDict` instance with Git configuration.
       kwargs: Additional arguments for urllib3.ProxyManager
 
     Returns:
       `pool_manager_cls` (defaults to `urllib3.ProxyManager`) instance for
       proxy configurations, `proxy_manager_cls` (defaults to
       `urllib3.PoolManager`) instance otherwise.
 
     """
     proxy_server = user_agent = None
     ca_certs = ssl_verify = None
 
     if proxy_server is None:
         for proxyname in ("https_proxy", "http_proxy", "all_proxy"):
             proxy_server = os.environ.get(proxyname)
             if proxy_server is not None:
                 break
 
     if config is not None:
         if proxy_server is None:
             try:
                 proxy_server = config.get(b"http", b"proxy")
             except KeyError:
                 pass
         try:
             user_agent = config.get(b"http", b"useragent")
         except KeyError:
             pass
 
         # TODO(jelmer): Support per-host settings
         try:
             ssl_verify = config.get_boolean(b"http", b"sslVerify")
         except KeyError:
             ssl_verify = True
 
         try:
             ca_certs = config.get(b"http", b"sslCAInfo")
         except KeyError:
             ca_certs = None
 
     if user_agent is None:
         user_agent = default_user_agent_string()
 
     headers = {"User-agent": user_agent}
 
     kwargs = {}
     if ssl_verify is True:
         kwargs["cert_reqs"] = "CERT_REQUIRED"
     elif ssl_verify is False:
         kwargs["cert_reqs"] = "CERT_NONE"
     else:
         # Default to SSL verification
         kwargs["cert_reqs"] = "CERT_REQUIRED"
 
     if ca_certs is not None:
         kwargs["ca_certs"] = ca_certs
     kwargs.update(override_kwargs)
 
     # Try really hard to find a SSL certificate path
     if "ca_certs" not in kwargs and kwargs.get("cert_reqs") != "CERT_NONE":
         try:
             import certifi
         except ImportError:
             pass
         else:
             kwargs["ca_certs"] = certifi.where()
 
     import urllib3
 
     if proxy_server is not None:
         if proxy_manager_cls is None:
             proxy_manager_cls = urllib3.ProxyManager
-        # `urllib3` requires a `str` object in both Python 2 and 3, while
-        # `ConfigDict` coerces entries to `bytes` on Python 3. Compensate.
         if not isinstance(proxy_server, str):
             proxy_server = proxy_server.decode()
         manager = proxy_manager_cls(proxy_server, headers=headers, **kwargs)
     else:
         if pool_manager_cls is None:
             pool_manager_cls = urllib3.PoolManager
         manager = pool_manager_cls(headers=headers, **kwargs)
 
     return manager
 
 
-class HttpGitClient(GitClient):
-    def __init__(
-        self,
-        base_url,
-        dumb=None,
-        pool_manager=None,
-        config=None,
-        username=None,
-        password=None,
-        **kwargs
-    ):
-        self._base_url = base_url.rstrip("/") + "/"
-        self._username = username
-        self._password = password
-        self.dumb = dumb
-
-        if pool_manager is None:
-            self.pool_manager = default_urllib3_manager(config)
-        else:
-            self.pool_manager = pool_manager
+class AbstractHttpGitClient(GitClient):
+    """Abstract base class for HTTP Git Clients.
 
-        if username is not None:
-            # No escaping needed: ":" is not allowed in username:
-            # https://tools.ietf.org/html/rfc2617#section-2
-            credentials = "%s:%s" % (username, password)
-            import urllib3.util
+    This is agonistic of the actual HTTP implementation.
 
-            basic_auth = urllib3.util.make_headers(basic_auth=credentials)
-            self.pool_manager.headers.update(basic_auth)
+    Subclasses should provide an implementation of the
+    _http_request method.
+    """
 
+    def __init__(self, base_url, dumb=False, **kwargs):
+        self._base_url = base_url.rstrip("/") + "/"
+        self.dumb = dumb
         GitClient.__init__(self, **kwargs)
 
-    def get_url(self, path):
-        return self._get_url(path).rstrip("/")
-
-    @classmethod
-    def from_parsedurl(cls, parsedurl, **kwargs):
-        password = parsedurl.password
-        if password is not None:
-            kwargs["password"] = urlunquote(password)
-        username = parsedurl.username
-        if username is not None:
-            kwargs["username"] = urlunquote(username)
-        netloc = parsedurl.hostname
-        if parsedurl.port:
-            netloc = "%s:%s" % (netloc, parsedurl.port)
-        if parsedurl.username:
-            netloc = "%s@%s" % (parsedurl.username, netloc)
-        parsedurl = parsedurl._replace(netloc=netloc)
-        return cls(urlunparse(parsedurl), **kwargs)
-
-    def __repr__(self):
-        return "%s(%r, dumb=%r)" % (
-            type(self).__name__,
-            self._base_url,
-            self.dumb,
-        )
-
-    def _get_url(self, path):
-        if not isinstance(path, str):
-            # urllib3.util.url._encode_invalid_chars() converts the path back
-            # to bytes using the utf-8 codec.
-            path = path.decode("utf-8")
-        return urljoin(self._base_url, path).rstrip("/") + "/"
-
     def _http_request(self, url, headers=None, data=None, allow_compression=False):
         """Perform HTTP request.
 
         Args:
           url: Request URL.
           headers: Optional custom headers to override defaults.
           data: Request data.
           allow_compression: Allow GZipped communication.
 
         Returns:
           Tuple (`response`, `read`), where response is an `urllib3`
           response object with additional `content_type` and
           `redirect_location` properties, and `read` is a consumable read
           method for the response data.
 
         """
-        req_headers = self.pool_manager.headers.copy()
-        if headers is not None:
-            req_headers.update(headers)
-        req_headers["Pragma"] = "no-cache"
-        if allow_compression:
-            req_headers["Accept-Encoding"] = "gzip"
-        else:
-            req_headers["Accept-Encoding"] = "identity"
-
-        if data is None:
-            resp = self.pool_manager.request("GET", url, headers=req_headers)
-        else:
-            resp = self.pool_manager.request(
-                "POST", url, headers=req_headers, body=data
-            )
 
-        if resp.status == 404:
-            raise NotGitRepository()
-        if resp.status == 401:
-            raise HTTPUnauthorized(resp.getheader("WWW-Authenticate"), url)
-        if resp.status != 200:
-            raise GitProtocolError(
-                "unexpected http resp %d for %s" % (resp.status, url)
-            )
-
-        # TODO: Optimization available by adding `preload_content=False` to the
-        # request and just passing the `read` method on instead of going via
-        # `BytesIO`, if we can guarantee that the entire response is consumed
-        # before issuing the next to still allow for connection reuse from the
-        # pool.
-        read = BytesIO(resp.data).read
-
-        resp.content_type = resp.getheader("Content-Type")
-        # Check if geturl() is available (urllib3 version >= 1.23)
-        try:
-            resp_url = resp.geturl()
-        except AttributeError:
-            # get_redirect_location() is available for urllib3 >= 1.1
-            resp.redirect_location = resp.get_redirect_location()
-        else:
-            resp.redirect_location = resp_url if resp_url != url else ""
-        return resp, read
+        raise NotImplementedError(self._http_request)
 
     def _discover_references(self, service, base_url):
         assert base_url[-1] == "/"
         tail = "info/refs"
         headers = {"Accept": "*/*"}
         if self.dumb is not True:
             tail += "?service=%s" % service.decode("ascii")
         url = urljoin(base_url, tail)
         resp, read = self._http_request(url, headers, allow_compression=True)
 
         if resp.redirect_location:
             # Something changed (redirect!), so let's update the base URL
             if not resp.redirect_location.endswith(tail):
                 raise GitProtocolError(
                     "Redirected from URL %s to URL %s without %s"
                     % (url, resp.redirect_location, tail)
                 )
             base_url = resp.redirect_location[: -len(tail)]
 
         try:
             self.dumb = not resp.content_type.startswith("application/x-git-")
             if not self.dumb:
                 proto = Protocol(read, None)
                 # The first line should mention the service
                 try:
                     [pkt] = list(proto.read_pkt_seq())
                 except ValueError:
                     raise GitProtocolError("unexpected number of packets received")
                 if pkt.rstrip(b"\n") != (b"# service=" + service):
                     raise GitProtocolError(
                         "unexpected first line %r from smart server" % pkt
                     )
                 return read_pkt_refs(proto) + (base_url,)
             else:
                 return read_info_refs(resp), set(), base_url
         finally:
             resp.close()
 
     def _smart_request(self, service, url, data):
+        """Send a 'smart' HTTP request.
+
+        This is a simple wrapper around _http_request that sets
+        a couple of extra headers.
+        """
         assert url[-1] == "/"
         url = urljoin(url, service)
         result_content_type = "application/x-%s-result" % service
         headers = {
             "Content-Type": "application/x-%s-request" % service,
             "Accept": result_content_type,
             "Content-Length": str(len(data)),
         }
         resp, read = self._http_request(url, headers, data)
         if resp.content_type != result_content_type:
             raise GitProtocolError(
                 "Invalid content-type from server: %s" % resp.content_type
             )
         return resp, read
 
     def send_pack(self, path, update_refs, generate_pack_data, progress=None):
         """Upload a pack to a remote repository.
 
         Args:
           path: Repository path (as bytestring)
           update_refs: Function to determine changes to remote refs.
-        Receives dict with existing remote refs, returns dict with
-        changed refs (name -> sha, where sha=ZERO_SHA for deletions)
+            Receives dict with existing remote refs, returns dict with
+            changed refs (name -> sha, where sha=ZERO_SHA for deletions)
           generate_pack_data: Function that can return a tuple
-        with number of elements and pack data to upload.
+            with number of elements and pack data to upload.
           progress: Optional progress function
 
         Returns:
           SendPackResult
 
         Raises:
           SendPackError: if server rejects the pack data
 
         """
         url = self._get_url(path)
         old_refs, server_capabilities, url = self._discover_references(
             b"git-receive-pack", url
         )
         (
             negotiated_capabilities,
             agent,
         ) = self._negotiate_receive_pack_capabilities(server_capabilities)
         negotiated_capabilities.add(capability_agent())
 
         if CAPABILITY_REPORT_STATUS in negotiated_capabilities:
             self._report_status_parser = ReportStatusParser()
 
         new_refs = update_refs(dict(old_refs))
         if new_refs is None:
             # Determine wants function is aborting the push.
             return SendPackResult(old_refs, agent=agent, ref_status={})
         if set(new_refs.items()).issubset(set(old_refs.items())):
             return SendPackResult(new_refs, agent=agent, ref_status={})
         if self.dumb:
             raise NotImplementedError(self.fetch_pack)
         req_data = BytesIO()
         req_proto = Protocol(None, req_data.write)
         (have, want) = self._handle_receive_pack_head(
             req_proto, negotiated_capabilities, old_refs, new_refs
         )
         pack_data_count, pack_data = generate_pack_data(
             have,
             want,
             ofs_delta=(CAPABILITY_OFS_DELTA in negotiated_capabilities),
         )
         if self._should_send_pack(new_refs):
             write_pack_data(req_proto.write_file(), pack_data_count, pack_data)
         resp, read = self._smart_request(
             "git-receive-pack", url, data=req_data.getvalue()
         )
         try:
             resp_proto = Protocol(read, None)
             ref_status = self._handle_receive_pack_tail(
                 resp_proto, negotiated_capabilities, progress
             )
             return SendPackResult(new_refs, agent=agent, ref_status=ref_status)
         finally:
             resp.close()
 
     def fetch_pack(
         self,
         path,
         determine_wants,
         graph_walker,
         pack_data,
         progress=None,
         depth=None,
     ):
         """Retrieve a pack from a git smart server.
 
         Args:
           path: Path to fetch from
           determine_wants: Callback that returns list of commits to fetch
           graph_walker: Object with next() and ack().
           pack_data: Callback called for each bit of data in the pack
           progress: Callback for progress reports (strings)
           depth: Depth for request
 
         Returns:
           FetchPackResult object
 
         """
         url = self._get_url(path)
         refs, server_capabilities, url = self._discover_references(
             b"git-upload-pack", url
         )
         (
             negotiated_capabilities,
             symrefs,
             agent,
         ) = self._negotiate_upload_pack_capabilities(server_capabilities)
         if depth is not None:
             wants = determine_wants(refs, depth=depth)
         else:
             wants = determine_wants(refs)
         if wants is not None:
             wants = [cid for cid in wants if cid != ZERO_SHA]
         if not wants:
             return FetchPackResult(refs, symrefs, agent)
         if self.dumb:
             raise NotImplementedError(self.fetch_pack)
         req_data = BytesIO()
         req_proto = Protocol(None, req_data.write)
         (new_shallow, new_unshallow) = self._handle_upload_pack_head(
             req_proto,
             negotiated_capabilities,
             graph_walker,
             wants,
             can_read=None,
             depth=depth,
         )
         resp, read = self._smart_request(
             "git-upload-pack", url, data=req_data.getvalue()
         )
         try:
             resp_proto = Protocol(read, None)
             if new_shallow is None and new_unshallow is None:
                 (new_shallow, new_unshallow) = _read_shallow_updates(resp_proto)
             self._handle_upload_pack_tail(
                 resp_proto,
                 negotiated_capabilities,
                 graph_walker,
                 pack_data,
                 progress,
             )
             return FetchPackResult(refs, symrefs, agent, new_shallow, new_unshallow)
         finally:
             resp.close()
 
     def get_refs(self, path):
         """Retrieve the current refs from a git smart server."""
         url = self._get_url(path)
         refs, _, _ = self._discover_references(b"git-upload-pack", url)
         return refs
 
+    def get_url(self, path):
+        return self._get_url(path).rstrip("/")
+
+    def _get_url(self, path):
+        return urljoin(self._base_url, path).rstrip("/") + "/"
+
+    @classmethod
+    def from_parsedurl(cls, parsedurl, **kwargs):
+        password = parsedurl.password
+        if password is not None:
+            kwargs["password"] = urlunquote(password)
+        username = parsedurl.username
+        if username is not None:
+            kwargs["username"] = urlunquote(username)
+        netloc = parsedurl.hostname
+        if parsedurl.port:
+            netloc = "%s:%s" % (netloc, parsedurl.port)
+        if parsedurl.username:
+            netloc = "%s@%s" % (parsedurl.username, netloc)
+        parsedurl = parsedurl._replace(netloc=netloc)
+        return cls(urlunparse(parsedurl), **kwargs)
+
+    def __repr__(self):
+        return "%s(%r, dumb=%r)" % (
+            type(self).__name__,
+            self._base_url,
+            self.dumb,
+        )
+
+
+class Urllib3HttpGitClient(AbstractHttpGitClient):
+    def __init__(
+        self,
+        base_url,
+        dumb=None,
+        pool_manager=None,
+        config=None,
+        username=None,
+        password=None,
+        **kwargs
+    ):
+        self._username = username
+        self._password = password
+
+        if pool_manager is None:
+            self.pool_manager = default_urllib3_manager(config)
+        else:
+            self.pool_manager = pool_manager
+
+        if username is not None:
+            # No escaping needed: ":" is not allowed in username:
+            # https://tools.ietf.org/html/rfc2617#section-2
+            credentials = "%s:%s" % (username, password)
+            import urllib3.util
+
+            basic_auth = urllib3.util.make_headers(basic_auth=credentials)
+            self.pool_manager.headers.update(basic_auth)
+
+        super(Urllib3HttpGitClient, self).__init__(
+            base_url=base_url, dumb=dumb, **kwargs)
+
+    def _get_url(self, path):
+        if not isinstance(path, str):
+            # urllib3.util.url._encode_invalid_chars() converts the path back
+            # to bytes using the utf-8 codec.
+            path = path.decode("utf-8")
+        return urljoin(self._base_url, path).rstrip("/") + "/"
+
+    def _http_request(self, url, headers=None, data=None, allow_compression=False):
+        req_headers = self.pool_manager.headers.copy()
+        if headers is not None:
+            req_headers.update(headers)
+        req_headers["Pragma"] = "no-cache"
+        if allow_compression:
+            req_headers["Accept-Encoding"] = "gzip"
+        else:
+            req_headers["Accept-Encoding"] = "identity"
+
+        if data is None:
+            resp = self.pool_manager.request("GET", url, headers=req_headers)
+        else:
+            resp = self.pool_manager.request(
+                "POST", url, headers=req_headers, body=data
+            )
+
+        if resp.status == 404:
+            raise NotGitRepository()
+        if resp.status == 401:
+            raise HTTPUnauthorized(resp.getheader("WWW-Authenticate"), url)
+        if resp.status == 407:
+            raise HTTPProxyUnauthorized(resp.getheader("Proxy-Authenticate"), url)
+        if resp.status != 200:
+            raise GitProtocolError(
+                "unexpected http resp %d for %s" % (resp.status, url)
+            )
+
+        # TODO: Optimization available by adding `preload_content=False` to the
+        # request and just passing the `read` method on instead of going via
+        # `BytesIO`, if we can guarantee that the entire response is consumed
+        # before issuing the next to still allow for connection reuse from the
+        # pool.
+        read = BytesIO(resp.data).read
+
+        resp.content_type = resp.getheader("Content-Type")
+        # Check if geturl() is available (urllib3 version >= 1.23)
+        try:
+            resp_url = resp.geturl()
+        except AttributeError:
+            # get_redirect_location() is available for urllib3 >= 1.1
+            resp.redirect_location = resp.get_redirect_location()
+        else:
+            resp.redirect_location = resp_url if resp_url != url else ""
+        return resp, read
+
+
+HttpGitClient = Urllib3HttpGitClient
+
 
 def get_transport_and_path_from_url(url, config=None, **kwargs):
     """Obtain a git client from a URL.
 
     Args:
       url: URL to open (a unicode string)
       config: Optional config object
       thin_packs: Whether or not thin packs should be retrieved
       report_activity: Optional callback for reporting transport
         activity.
 
     Returns:
       Tuple with client instance and relative path.
 
     """
     parsed = urlparse(url)
     if parsed.scheme == "git":
         return (TCPGitClient.from_parsedurl(parsed, **kwargs), parsed.path)
     elif parsed.scheme in ("git+ssh", "ssh"):
         return SSHGitClient.from_parsedurl(parsed, **kwargs), parsed.path
     elif parsed.scheme in ("http", "https"):
         return (
             HttpGitClient.from_parsedurl(parsed, config=config, **kwargs),
             parsed.path,
         )
     elif parsed.scheme == "file":
         return (
             default_local_git_client_cls.from_parsedurl(parsed, **kwargs),
             parsed.path,
         )
 
     raise ValueError("unknown scheme '%s'" % parsed.scheme)
 
 
 def parse_rsync_url(location):
     """Parse a rsync-style URL."""
     if ":" in location and "@" not in location:
         # SSH with no user@, zero or one leading slash.
         (host, path) = location.split(":", 1)
         user = None
     elif ":" in location:
         # SSH with user@host:foo.
         user_host, path = location.split(":", 1)
         if "@" in user_host:
             user, host = user_host.rsplit("@", 1)
         else:
             user = None
             host = user_host
     else:
         raise ValueError("not a valid rsync-style URL")
     return (user, host, path)
 
 
 def get_transport_and_path(location, **kwargs):
     """Obtain a git client from a URL.
 
     Args:
       location: URL or path (a string)
       config: Optional config object
       thin_packs: Whether or not thin packs should be retrieved
       report_activity: Optional callback for reporting transport
         activity.
 
     Returns:
       Tuple with client instance and relative path.
 
     """
     # First, try to parse it as a URL
     try:
         return get_transport_and_path_from_url(location, **kwargs)
     except ValueError:
         pass
 
     if sys.platform == "win32" and location[0].isalpha() and location[1:3] == ":\\":
         # Windows local path
         return default_local_git_client_cls(**kwargs), location
 
     try:
         (username, hostname, path) = parse_rsync_url(location)
     except ValueError:
         # Otherwise, assume it's a local path.
         return default_local_git_client_cls(**kwargs), location
     else:
         return SSHGitClient(hostname, username=username, **kwargs), path
 
 
 DEFAULT_GIT_CREDENTIALS_PATHS = [
     os.path.expanduser("~/.git-credentials"),
     get_xdg_config_home_path("git", "credentials"),
 ]
 
 
 def get_credentials_from_store(
     scheme, hostname, username=None, fnames=DEFAULT_GIT_CREDENTIALS_PATHS
 ):
     for fname in fnames:
         try:
             with open(fname, "rb") as f:
                 for line in f:
                     parsed_line = urlparse(line.strip())
                     if (
                         parsed_line.scheme == scheme
                         and parsed_line.hostname == hostname
                         and (username is None or parsed_line.username == username)
                     ):
                         return parsed_line.username, parsed_line.password
         except FileNotFoundError:
             # If the file doesn't exist, try the next one.
             continue
diff --git a/dulwich/config.py b/dulwich/config.py
index 7868faec..65f7de9e 100644
--- a/dulwich/config.py
+++ b/dulwich/config.py
@@ -1,620 +1,622 @@
 # config.py - Reading and writing Git config files
 # Copyright (C) 2011-2013 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.
 #
 
 """Reading and writing Git configuration files.
 
 TODO:
  * preserve formatting when updating configuration files
  * treat subsection names as case-insensitive for [branch.foo] style
    subsections
 """
 
 import os
 import sys
 
 from typing import BinaryIO, Tuple, Optional
 
 from collections import (
     OrderedDict,
 )
 
 try:
     from collections.abc import (
         Iterable,
         MutableMapping,
     )
 except ImportError:  # python < 3.7
-    from collections import (
+    from collections import (  # type: ignore
         Iterable,
         MutableMapping,
     )
 
 from dulwich.file import GitFile
 
 
 SENTINAL = object()
 
 
 def lower_key(key):
     if isinstance(key, (bytes, str)):
         return key.lower()
 
     if isinstance(key, Iterable):
         return type(key)(map(lower_key, key))
 
     return key
 
 
 class CaseInsensitiveDict(OrderedDict):
     @classmethod
     def make(cls, dict_in=None):
 
         if isinstance(dict_in, cls):
             return dict_in
 
         out = cls()
 
         if dict_in is None:
             return out
 
         if not isinstance(dict_in, MutableMapping):
             raise TypeError
 
         for key, value in dict_in.items():
             out[key] = value
 
         return out
 
     def __setitem__(self, key, value, **kwargs):
         key = lower_key(key)
 
         super(CaseInsensitiveDict, self).__setitem__(key, value, **kwargs)
 
     def __getitem__(self, item):
         key = lower_key(item)
 
         return super(CaseInsensitiveDict, self).__getitem__(key)
 
     def get(self, key, default=SENTINAL):
         try:
             return self[key]
         except KeyError:
             pass
 
         if default is SENTINAL:
             return type(self)()
 
         return default
 
     def setdefault(self, key, default=SENTINAL):
         try:
             return self[key]
         except KeyError:
             self[key] = self.get(key, default)
 
         return self[key]
 
 
 class Config(object):
     """A Git configuration."""
 
     def get(self, section, name):
         """Retrieve the contents of a configuration setting.
 
         Args:
           section: Tuple with section name and optional subsection namee
           subsection: Subsection name
         Returns:
           Contents of the setting
         Raises:
           KeyError: if the value is not set
         """
         raise NotImplementedError(self.get)
 
     def get_boolean(self, section, name, default=None):
         """Retrieve a configuration setting as boolean.
 
         Args:
           section: Tuple with section name and optional subsection name
           name: Name of the setting, including section and possible
             subsection.
         Returns:
           Contents of the setting
         Raises:
           KeyError: if the value is not set
         """
         try:
             value = self.get(section, name)
         except KeyError:
             return default
         if value.lower() == b"true":
             return True
         elif value.lower() == b"false":
             return False
         raise ValueError("not a valid boolean string: %r" % value)
 
     def set(self, section, name, value):
         """Set a configuration value.
 
         Args:
           section: Tuple with section name and optional subsection namee
           name: Name of the configuration value, including section
             and optional subsection
            value: value of the setting
         """
         raise NotImplementedError(self.set)
 
     def iteritems(self, section):
         """Iterate over the configuration pairs for a specific section.
 
         Args:
           section: Tuple with section name and optional subsection namee
         Returns:
           Iterator over (name, value) pairs
         """
         raise NotImplementedError(self.iteritems)
 
     def itersections(self):
         """Iterate over the sections.
 
         Returns: Iterator over section tuples
         """
         raise NotImplementedError(self.itersections)
 
     def has_section(self, name):
         """Check if a specified section exists.
 
         Args:
           name: Name of section to check for
         Returns:
           boolean indicating whether the section exists
         """
         return name in self.itersections()
 
 
 class ConfigDict(Config, MutableMapping):
     """Git configuration stored in a dictionary."""
 
     def __init__(self, values=None, encoding=None):
         """Create a new ConfigDict."""
         if encoding is None:
             encoding = sys.getdefaultencoding()
         self.encoding = encoding
         self._values = CaseInsensitiveDict.make(values)
 
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__, self._values)
 
     def __eq__(self, other):
         return isinstance(other, self.__class__) and other._values == self._values
 
     def __getitem__(self, key):
         return self._values.__getitem__(key)
 
     def __setitem__(self, key, value):
         return self._values.__setitem__(key, value)
 
     def __delitem__(self, key):
         return self._values.__delitem__(key)
 
     def __iter__(self):
         return self._values.__iter__()
 
     def __len__(self):
         return self._values.__len__()
 
     @classmethod
     def _parse_setting(cls, name):
         parts = name.split(".")
         if len(parts) == 3:
             return (parts[0], parts[1], parts[2])
         else:
             return (parts[0], None, parts[1])
 
     def _check_section_and_name(self, section, name):
         if not isinstance(section, tuple):
             section = (section,)
 
         section = tuple(
             [
                 subsection.encode(self.encoding)
                 if not isinstance(subsection, bytes)
                 else subsection
                 for subsection in section
             ]
         )
 
         if not isinstance(name, bytes):
             name = name.encode(self.encoding)
 
         return section, name
 
     def get(self, section, name):
         section, name = self._check_section_and_name(section, name)
 
         if len(section) > 1:
             try:
                 return self._values[section][name]
             except KeyError:
                 pass
 
         return self._values[(section[0],)][name]
 
     def set(self, section, name, value):
         section, name = self._check_section_and_name(section, name)
 
         if type(value) not in (bool, bytes):
             value = value.encode(self.encoding)
 
         self._values.setdefault(section)[name] = value
 
     def iteritems(self, section):
         return self._values.get(section).items()
 
     def itersections(self):
         return self._values.keys()
 
 
 def _format_string(value):
     if (
         value.startswith(b" ")
         or value.startswith(b"\t")
         or value.endswith(b" ")
         or b"#" in value
         or value.endswith(b"\t")
     ):
         return b'"' + _escape_value(value) + b'"'
     else:
         return _escape_value(value)
 
 
 _ESCAPE_TABLE = {
     ord(b"\\"): ord(b"\\"),
     ord(b'"'): ord(b'"'),
     ord(b"n"): ord(b"\n"),
     ord(b"t"): ord(b"\t"),
     ord(b"b"): ord(b"\b"),
 }
 _COMMENT_CHARS = [ord(b"#"), ord(b";")]
 _WHITESPACE_CHARS = [ord(b"\t"), ord(b" ")]
 
 
 def _parse_string(value):
     value = bytearray(value.strip())
     ret = bytearray()
     whitespace = bytearray()
     in_quotes = False
     i = 0
     while i < len(value):
         c = value[i]
         if c == ord(b"\\"):
             i += 1
             try:
                 v = _ESCAPE_TABLE[value[i]]
             except IndexError:
                 raise ValueError(
                     "escape character in %r at %d before end of string" % (value, i)
                 )
             except KeyError:
                 raise ValueError(
                     "escape character followed by unknown character "
                     "%s at %d in %r" % (value[i], i, value)
                 )
             if whitespace:
                 ret.extend(whitespace)
                 whitespace = bytearray()
             ret.append(v)
         elif c == ord(b'"'):
             in_quotes = not in_quotes
         elif c in _COMMENT_CHARS and not in_quotes:
             # the rest of the line is a comment
             break
         elif c in _WHITESPACE_CHARS:
             whitespace.append(c)
         else:
             if whitespace:
                 ret.extend(whitespace)
                 whitespace = bytearray()
             ret.append(c)
         i += 1
 
     if in_quotes:
         raise ValueError("missing end quote")
 
     return bytes(ret)
 
 
 def _escape_value(value):
     """Escape a value."""
     value = value.replace(b"\\", b"\\\\")
     value = value.replace(b"\n", b"\\n")
     value = value.replace(b"\t", b"\\t")
     value = value.replace(b'"', b'\\"')
     return value
 
 
 def _check_variable_name(name):
     for i in range(len(name)):
         c = name[i : i + 1]
         if not c.isalnum() and c != b"-":
             return False
     return True
 
 
 def _check_section_name(name):
     for i in range(len(name)):
         c = name[i : i + 1]
         if not c.isalnum() and c not in (b"-", b"."):
             return False
     return True
 
 
 def _strip_comments(line):
     comment_bytes = {ord(b"#"), ord(b";")}
     quote = ord(b'"')
     string_open = False
     # Normalize line to bytearray for simple 2/3 compatibility
     for i, character in enumerate(bytearray(line)):
         # Comment characters outside balanced quotes denote comment start
         if character == quote:
             string_open = not string_open
         elif not string_open and character in comment_bytes:
             return line[:i]
     return line
 
 
 class ConfigFile(ConfigDict):
     """A Git configuration file, like .git/config or ~/.gitconfig."""
 
     def __init__(self, values=None, encoding=None):
         super(ConfigFile, self).__init__(values=values, encoding=encoding)
         self.path = None
 
-    @classmethod
-    def from_file(cls, f: BinaryIO) -> "ConfigFile":
+    @classmethod  # noqa: C901
+    def from_file(cls, f: BinaryIO) -> "ConfigFile":  # noqa: C901
         """Read configuration from a file-like object."""
         ret = cls()
         section = None  # type: Optional[Tuple[bytes, ...]]
         setting = None
         continuation = None
         for lineno, line in enumerate(f.readlines()):
+            if lineno == 0 and line.startswith(b'\xef\xbb\xbf'):
+                line = line[3:]
             line = line.lstrip()
             if setting is None:
                 # Parse section header ("[bla]")
                 if len(line) > 0 and line[:1] == b"[":
                     line = _strip_comments(line).rstrip()
                     try:
                         last = line.index(b"]")
                     except ValueError:
                         raise ValueError("expected trailing ]")
                     pts = line[1:last].split(b" ", 1)
                     line = line[last + 1 :]
                     if len(pts) == 2:
                         if pts[1][:1] != b'"' or pts[1][-1:] != b'"':
                             raise ValueError("Invalid subsection %r" % pts[1])
                         else:
                             pts[1] = pts[1][1:-1]
                         if not _check_section_name(pts[0]):
                             raise ValueError("invalid section name %r" % pts[0])
                         section = (pts[0], pts[1])
                     else:
                         if not _check_section_name(pts[0]):
                             raise ValueError("invalid section name %r" % pts[0])
                         pts = pts[0].split(b".", 1)
                         if len(pts) == 2:
                             section = (pts[0], pts[1])
                         else:
                             section = (pts[0],)
                     ret._values.setdefault(section)
                 if _strip_comments(line).strip() == b"":
                     continue
                 if section is None:
                     raise ValueError("setting %r without section" % line)
                 try:
                     setting, value = line.split(b"=", 1)
                 except ValueError:
                     setting = line
                     value = b"true"
                 setting = setting.strip()
                 if not _check_variable_name(setting):
                     raise ValueError("invalid variable name %r" % setting)
                 if value.endswith(b"\\\n"):
                     continuation = value[:-2]
                 else:
                     continuation = None
                     value = _parse_string(value)
                     ret._values[section][setting] = value
                     setting = None
             else:  # continuation line
                 if line.endswith(b"\\\n"):
                     continuation += line[:-2]
                 else:
                     continuation += line
                     value = _parse_string(continuation)
                     ret._values[section][setting] = value
                     continuation = None
                     setting = None
         return ret
 
     @classmethod
     def from_path(cls, path) -> "ConfigFile":
         """Read configuration from a file on disk."""
         with GitFile(path, "rb") as f:
             ret = cls.from_file(f)
             ret.path = path
             return ret
 
     def write_to_path(self, path=None) -> None:
         """Write configuration to a file on disk."""
         if path is None:
             path = self.path
         with GitFile(path, "wb") as f:
             self.write_to_file(f)
 
     def write_to_file(self, f: BinaryIO) -> None:
         """Write configuration to a file-like object."""
         for section, values in self._values.items():
             try:
                 section_name, subsection_name = section
             except ValueError:
                 (section_name,) = section
                 subsection_name = None
             if subsection_name is None:
                 f.write(b"[" + section_name + b"]\n")
             else:
                 f.write(b"[" + section_name + b' "' + subsection_name + b'"]\n')
             for key, value in values.items():
                 if value is True:
                     value = b"true"
                 elif value is False:
                     value = b"false"
                 else:
                     value = _format_string(value)
                 f.write(b"\t" + key + b" = " + value + b"\n")
 
 
 def get_xdg_config_home_path(*path_segments):
     xdg_config_home = os.environ.get(
         "XDG_CONFIG_HOME",
         os.path.expanduser("~/.config/"),
     )
     return os.path.join(xdg_config_home, *path_segments)
 
 
 def _find_git_in_win_path():
     for exe in ("git.exe", "git.cmd"):
         for path in os.environ.get("PATH", "").split(";"):
             if os.path.exists(os.path.join(path, exe)):
                 # exe path is .../Git/bin/git.exe or .../Git/cmd/git.exe
                 git_dir, _bin_dir = os.path.split(path)
                 yield git_dir
                 break
 
 
 def _find_git_in_win_reg():
     import platform
     import winreg
 
     if platform.machine() == "AMD64":
         subkey = (
             "SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\"
             "CurrentVersion\\Uninstall\\Git_is1"
         )
     else:
         subkey = (
             "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\"
             "Uninstall\\Git_is1"
         )
 
     for key in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE):
         try:
             with winreg.OpenKey(key, subkey) as k:
                 val, typ = winreg.QueryValueEx(k, "InstallLocation")
                 if typ == winreg.REG_SZ:
                     yield val
         except OSError:
             pass
 
 
 # There is no set standard for system config dirs on windows. We try the
 # following:
 #   - %PROGRAMDATA%/Git/config - (deprecated) Windows config dir per CGit docs
 #   - %PROGRAMFILES%/Git/etc/gitconfig - Git for Windows (msysgit) config dir
 #     Used if CGit installation (Git/bin/git.exe) is found in PATH in the
 #     system registry
 def get_win_system_paths():
     if "PROGRAMDATA" in os.environ:
         yield os.path.join(os.environ["PROGRAMDATA"], "Git", "config")
 
     for git_dir in _find_git_in_win_path():
         yield os.path.join(git_dir, "etc", "gitconfig")
     for git_dir in _find_git_in_win_reg():
         yield os.path.join(git_dir, "etc", "gitconfig")
 
 
 class StackedConfig(Config):
     """Configuration which reads from multiple config files.."""
 
     def __init__(self, backends, writable=None):
         self.backends = backends
         self.writable = writable
 
     def __repr__(self):
         return "<%s for %r>" % (self.__class__.__name__, self.backends)
 
     @classmethod
     def default(cls):
         return cls(cls.default_backends())
 
     @classmethod
     def default_backends(cls):
         """Retrieve the default configuration.
 
         See git-config(1) for details on the files searched.
         """
         paths = []
         paths.append(os.path.expanduser("~/.gitconfig"))
         paths.append(get_xdg_config_home_path("git", "config"))
 
         if "GIT_CONFIG_NOSYSTEM" not in os.environ:
             paths.append("/etc/gitconfig")
             if sys.platform == "win32":
                 paths.extend(get_win_system_paths())
 
         backends = []
         for path in paths:
             try:
                 cf = ConfigFile.from_path(path)
             except FileNotFoundError:
                 continue
             backends.append(cf)
         return backends
 
     def get(self, section, name):
         if not isinstance(section, tuple):
             section = (section,)
         for backend in self.backends:
             try:
                 return backend.get(section, name)
             except KeyError:
                 pass
         raise KeyError(name)
 
     def set(self, section, name, value):
         if self.writable is None:
             raise NotImplementedError(self.set)
         return self.writable.set(section, name, value)
 
 
 def parse_submodules(config):
     """Parse a gitmodules GitConfig file, returning submodules.
 
     Args:
       config: A `ConfigFile`
     Returns:
       list of tuples (submodule path, url, name),
         where name is quoted part of the section's name.
     """
     for section in config.keys():
         section_kind, section_name = section
         if section_kind == b"submodule":
             sm_path = config.get(section, b"path")
             sm_url = config.get(section, b"url")
             yield (sm_path, sm_url, section_name)
diff --git a/dulwich/file.py b/dulwich/file.py
index 6abdc27d..acdec8c7 100644
--- a/dulwich/file.py
+++ b/dulwich/file.py
@@ -1,212 +1,217 @@
 # file.py -- Safe access to git files
 # Copyright (C) 2010 Google, Inc.
 #
 # 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.
 #
 
 """Safe access to git files."""
 
 import io
 import os
 import sys
 
 
 def ensure_dir_exists(dirname):
     """Ensure a directory exists, creating if necessary."""
     try:
         os.makedirs(dirname)
     except FileExistsError:
         pass
 
 
 def _fancy_rename(oldname, newname):
     """Rename file with temporary backup file to rollback if rename fails"""
     if not os.path.exists(newname):
         try:
             os.rename(oldname, newname)
         except OSError:
             raise
         return
 
     # Defer the tempfile import since it pulls in a lot of other things.
     import tempfile
 
     # destination file exists
     try:
         (fd, tmpfile) = tempfile.mkstemp(".tmp", prefix=oldname, dir=".")
         os.close(fd)
         os.remove(tmpfile)
     except OSError:
         # either file could not be created (e.g. permission problem)
         # or could not be deleted (e.g. rude virus scanner)
         raise
     try:
         os.rename(newname, tmpfile)
     except OSError:
         raise  # no rename occurred
     try:
         os.rename(oldname, newname)
     except OSError:
         os.rename(tmpfile, newname)
         raise
     os.remove(tmpfile)
 
 
-def GitFile(filename, mode="rb", bufsize=-1):
+def GitFile(filename, mode="rb", bufsize=-1, mask=0o644):
     """Create a file object that obeys the git file locking protocol.
 
     Returns: a builtin file object or a _GitFile object
 
     Note: See _GitFile for a description of the file locking protocol.
 
     Only read-only and write-only (binary) modes are supported; r+, w+, and a
     are not.  To read and write from the same file, you can take advantage of
     the fact that opening a file for write does not actually open the file you
     request.
+
+    The default file mask makes any created files user-writable and
+    world-readable.
+
     """
     if "a" in mode:
         raise IOError("append mode not supported for Git files")
     if "+" in mode:
         raise IOError("read/write mode not supported for Git files")
     if "b" not in mode:
         raise IOError("text mode not supported for Git files")
     if "w" in mode:
-        return _GitFile(filename, mode, bufsize)
+        return _GitFile(filename, mode, bufsize, mask)
     else:
         return io.open(filename, mode, bufsize)
 
 
 class FileLocked(Exception):
     """File is already locked."""
 
     def __init__(self, filename, lockfilename):
         self.filename = filename
         self.lockfilename = lockfilename
         super(FileLocked, self).__init__(filename, lockfilename)
 
 
 class _GitFile(object):
     """File that follows the git locking protocol for writes.
 
     All writes to a file foo will be written into foo.lock in the same
     directory, and the lockfile will be renamed to overwrite the original file
     on close.
 
     Note: You *must* call close() or abort() on a _GitFile for the lock to be
         released. Typically this will happen in a finally block.
     """
 
     PROXY_PROPERTIES = set(
         [
             "closed",
             "encoding",
             "errors",
             "mode",
             "name",
             "newlines",
             "softspace",
         ]
     )
     PROXY_METHODS = (
         "__iter__",
         "flush",
         "fileno",
         "isatty",
         "read",
         "readline",
         "readlines",
         "seek",
         "tell",
         "truncate",
         "write",
         "writelines",
     )
 
-    def __init__(self, filename, mode, bufsize):
+    def __init__(self, filename, mode, bufsize, mask):
         self._filename = filename
         if isinstance(self._filename, bytes):
             self._lockfilename = self._filename + b".lock"
         else:
             self._lockfilename = self._filename + ".lock"
         try:
             fd = os.open(
                 self._lockfilename,
                 os.O_RDWR | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0),
+                mask,
             )
         except FileExistsError:
             raise FileLocked(filename, self._lockfilename)
         self._file = os.fdopen(fd, mode, bufsize)
         self._closed = False
 
         for method in self.PROXY_METHODS:
             setattr(self, method, getattr(self._file, method))
 
     def abort(self):
         """Close and discard the lockfile without overwriting the target.
 
         If the file is already closed, this is a no-op.
         """
         if self._closed:
             return
         self._file.close()
         try:
             os.remove(self._lockfilename)
             self._closed = True
         except FileNotFoundError:
             # The file may have been removed already, which is ok.
             self._closed = True
 
     def close(self):
         """Close this file, saving the lockfile over the original.
 
         Note: If this method fails, it will attempt to delete the lockfile.
             However, it is not guaranteed to do so (e.g. if a filesystem
             becomes suddenly read-only), which will prevent future writes to
             this file until the lockfile is removed manually.
         Raises:
           OSError: if the original file could not be overwritten. The
             lock file is still closed, so further attempts to write to the same
             file object will raise ValueError.
         """
         if self._closed:
             return
         os.fsync(self._file.fileno())
         self._file.close()
         try:
             if getattr(os, "replace", None) is not None:
                 os.replace(self._lockfilename, self._filename)
             else:
                 if sys.platform != "win32":
                     os.rename(self._lockfilename, self._filename)
                 else:
                     # Windows versions prior to Vista don't support atomic
                     # renames
                     _fancy_rename(self._lockfilename, self._filename)
         finally:
             self.abort()
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
     def __getattr__(self, name):
         """Proxy property calls to the underlying file."""
         if name in self.PROXY_PROPERTIES:
             return getattr(self._file, name)
         raise AttributeError(name)
diff --git a/dulwich/ignore.py b/dulwich/ignore.py
index cc457a22..b75560f3 100644
--- a/dulwich/ignore.py
+++ b/dulwich/ignore.py
@@ -1,391 +1,391 @@
 # Copyright (C) 2017 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.
 #
 
 """Parsing of gitignore files.
 
 For details for the matching rules, see https://git-scm.com/docs/gitignore
 """
 
 import os.path
 import re
 from typing import (
     BinaryIO,
     Iterable,
     List,
     Optional,
     TYPE_CHECKING,
     Dict,
     Union,
 )
 
 if TYPE_CHECKING:
     from dulwich.repo import Repo
 
 from dulwich.config import get_xdg_config_home_path, Config
 
 
 def _translate_segment(segment: bytes) -> bytes:
     if segment == b"*":
         return b"[^/]+"
     res = b""
     i, n = 0, len(segment)
     while i < n:
         c = segment[i : i + 1]
         i = i + 1
         if c == b"*":
             res += b"[^/]*"
         elif c == b"?":
             res += b"[^/]"
         elif c == b"[":
             j = i
             if j < n and segment[j : j + 1] == b"!":
                 j = j + 1
             if j < n and segment[j : j + 1] == b"]":
                 j = j + 1
             while j < n and segment[j : j + 1] != b"]":
                 j = j + 1
             if j >= n:
                 res += b"\\["
             else:
                 stuff = segment[i:j].replace(b"\\", b"\\\\")
                 i = j + 1
                 if stuff.startswith(b"!"):
                     stuff = b"^" + stuff[1:]
                 elif stuff.startswith(b"^"):
                     stuff = b"\\" + stuff
                 res += b"[" + stuff + b"]"
         else:
             res += re.escape(c)
     return res
 
 
 def translate(pat: bytes) -> bytes:
     """Translate a shell PATTERN to a regular expression.
 
     There is no way to quote meta-characters.
 
     Originally copied from fnmatch in Python 2.7, but modified for Dulwich
     to cope with features in Git ignore patterns.
     """
 
     res = b"(?ms)"
 
     if b"/" not in pat[:-1]:
         # If there's no slash, this is a filename-based match
         res += b"(.*/)?"
 
     if pat.startswith(b"**/"):
         # Leading **/
         pat = pat[2:]
         res += b"(.*/)?"
 
     if pat.startswith(b"/"):
         pat = pat[1:]
 
     for i, segment in enumerate(pat.split(b"/")):
         if segment == b"**":
             res += b"(/.*)?"
             continue
         else:
             res += (re.escape(b"/") if i > 0 else b"") + _translate_segment(segment)
 
     if not pat.endswith(b"/"):
         res += b"/?"
 
     return res + b"\\Z"
 
 
 def read_ignore_patterns(f: BinaryIO) -> Iterable[bytes]:
     """Read a git ignore file.
 
     Args:
       f: File-like object to read from
     Returns: List of patterns
     """
 
     for line in f:
         line = line.rstrip(b"\r\n")
 
         # Ignore blank lines, they're used for readability.
-        if not line:
+        if not line.strip():
             continue
 
         if line.startswith(b"#"):
             # Comment
             continue
 
         # Trailing spaces are ignored unless they are quoted with a backslash.
         while line.endswith(b" ") and not line.endswith(b"\\ "):
             line = line[:-1]
         line = line.replace(b"\\ ", b" ")
 
         yield line
 
 
 def match_pattern(path: bytes, pattern: bytes, ignorecase: bool = False) -> bool:
     """Match a gitignore-style pattern against a path.
 
     Args:
       path: Path to match
       pattern: Pattern to match
       ignorecase: Whether to do case-sensitive matching
     Returns:
       bool indicating whether the pattern matched
     """
     return Pattern(pattern, ignorecase).match(path)
 
 
 class Pattern(object):
     """A single ignore pattern."""
 
     def __init__(self, pattern: bytes, ignorecase: bool = False):
         self.pattern = pattern
         self.ignorecase = ignorecase
         if pattern[0:1] == b"!":
             self.is_exclude = False
             pattern = pattern[1:]
         else:
             if pattern[0:1] == b"\\":
                 pattern = pattern[1:]
             self.is_exclude = True
         flags = 0
         if self.ignorecase:
             flags = re.IGNORECASE
         self._re = re.compile(translate(pattern), flags)
 
     def __bytes__(self) -> bytes:
         return self.pattern
 
     def __str__(self) -> str:
         return os.fsdecode(self.pattern)
 
     def __eq__(self, other: object) -> bool:
         return (
             isinstance(other, type(self))
             and self.pattern == other.pattern
             and self.ignorecase == other.ignorecase
         )
 
     def __repr__(self) -> str:
         return "%s(%r, %r)" % (
             type(self).__name__,
             self.pattern,
             self.ignorecase,
         )
 
     def match(self, path: bytes) -> bool:
         """Try to match a path against this ignore pattern.
 
         Args:
           path: Path to match (relative to ignore location)
         Returns: boolean
         """
         return bool(self._re.match(path))
 
 
 class IgnoreFilter(object):
     def __init__(self, patterns: Iterable[bytes], ignorecase: bool = False, path=None):
         self._patterns = []  # type: List[Pattern]
         self._ignorecase = ignorecase
         self._path = path
         for pattern in patterns:
             self.append_pattern(pattern)
 
     def append_pattern(self, pattern: bytes) -> None:
         """Add a pattern to the set."""
         self._patterns.append(Pattern(pattern, self._ignorecase))
 
     def find_matching(self, path: Union[bytes, str]) -> Iterable[Pattern]:
         """Yield all matching patterns for path.
 
         Args:
           path: Path to match
         Returns:
           Iterator over iterators
         """
         if not isinstance(path, bytes):
             path = os.fsencode(path)
         for pattern in self._patterns:
             if pattern.match(path):
                 yield pattern
 
     def is_ignored(self, path: bytes) -> Optional[bool]:
         """Check whether a path is ignored.
 
         For directories, include a trailing slash.
 
         Returns: status is None if file is not mentioned, True if it is
             included, False if it is explicitly excluded.
         """
         status = None
         for pattern in self.find_matching(path):
             status = pattern.is_exclude
         return status
 
     @classmethod
     def from_path(cls, path, ignorecase: bool = False) -> "IgnoreFilter":
         with open(path, "rb") as f:
             return cls(read_ignore_patterns(f), ignorecase, path=path)
 
     def __repr__(self) -> str:
         path = getattr(self, "_path", None)
         if path is not None:
             return "%s.from_path(%r)" % (type(self).__name__, path)
         else:
             return "<%s>" % (type(self).__name__)
 
 
 class IgnoreFilterStack(object):
     """Check for ignore status in multiple filters."""
 
     def __init__(self, filters):
         self._filters = filters
 
     def is_ignored(self, path: str) -> Optional[bool]:
         """Check whether a path is explicitly included or excluded in ignores.
 
         Args:
           path: Path to check
         Returns:
           None if the file is not mentioned, True if it is included,
           False if it is explicitly excluded.
         """
         status = None
         for filter in self._filters:
             status = filter.is_ignored(path)
             if status is not None:
                 return status
         return status
 
 
 def default_user_ignore_filter_path(config: Config) -> str:
     """Return default user ignore filter path.
 
     Args:
       config: A Config object
     Returns:
       Path to a global ignore file
     """
     try:
         return config.get((b"core",), b"excludesFile")
     except KeyError:
         pass
 
     return get_xdg_config_home_path("git", "ignore")
 
 
 class IgnoreFilterManager(object):
     """Ignore file manager."""
 
     def __init__(
         self,
         top_path: str,
         global_filters: List[IgnoreFilter],
         ignorecase: bool,
     ):
         self._path_filters = {}  # type: Dict[str, Optional[IgnoreFilter]]
         self._top_path = top_path
         self._global_filters = global_filters
         self._ignorecase = ignorecase
 
     def __repr__(self) -> str:
         return "%s(%s, %r, %r)" % (
             type(self).__name__,
             self._top_path,
             self._global_filters,
             self._ignorecase,
         )
 
     def _load_path(self, path: str) -> Optional[IgnoreFilter]:
         try:
             return self._path_filters[path]
         except KeyError:
             pass
 
         p = os.path.join(self._top_path, path, ".gitignore")
         try:
             self._path_filters[path] = IgnoreFilter.from_path(p, self._ignorecase)
         except IOError:
             self._path_filters[path] = None
         return self._path_filters[path]
 
     def find_matching(self, path: str) -> Iterable[Pattern]:
         """Find matching patterns for path.
 
         Args:
           path: Path to check
         Returns:
           Iterator over Pattern instances
         """
         if os.path.isabs(path):
             raise ValueError("%s is an absolute path" % path)
         filters = [(0, f) for f in self._global_filters]
         if os.path.sep != "/":
             path = path.replace(os.path.sep, "/")
         parts = path.split("/")
         matches = []
         for i in range(len(parts) + 1):
             dirname = "/".join(parts[:i])
             for s, f in filters:
                 relpath = "/".join(parts[s:i])
                 if i < len(parts):
                     # Paths leading up to the final part are all directories,
                     # so need a trailing slash.
                     relpath += "/"
                 matches += list(f.find_matching(relpath))
             ignore_filter = self._load_path(dirname)
             if ignore_filter is not None:
                 filters.insert(0, (i, ignore_filter))
         return iter(matches)
 
     def is_ignored(self, path: str) -> Optional[bool]:
         """Check whether a path is explicitly included or excluded in ignores.
 
         Args:
           path: Path to check
         Returns:
           None if the file is not mentioned, True if it is included,
           False if it is explicitly excluded.
         """
         matches = list(self.find_matching(path))
         if matches:
             return matches[-1].is_exclude
         return None
 
     @classmethod
     def from_repo(cls, repo: "Repo") -> "IgnoreFilterManager":
         """Create a IgnoreFilterManager from a repository.
 
         Args:
           repo: Repository object
         Returns:
           A `IgnoreFilterManager` object
         """
         global_filters = []
         for p in [
             os.path.join(repo.controldir(), "info", "exclude"),
             default_user_ignore_filter_path(repo.get_config_stack()),
         ]:
             try:
                 global_filters.append(IgnoreFilter.from_path(os.path.expanduser(p)))
             except IOError:
                 pass
         config = repo.get_config_stack()
         ignorecase = config.get_boolean((b"core"), (b"ignorecase"), False)
         return cls(repo.path, global_filters, ignorecase)
diff --git a/dulwich/object_store.py b/dulwich/object_store.py
index 99c81638..551f9c1f 100644
--- a/dulwich/object_store.py
+++ b/dulwich/object_store.py
@@ -1,1597 +1,1604 @@
 # 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
 
 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,
     load_pack_index_file,
     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.protocol import DEPTH_INFINITE
 from dulwich.refs import ANNOTATED_TAG_SUFFIX
 
 INFODIR = "info"
 PACKDIR = "pack"
 
+# use permissions consistent with Git; just readable by everyone
+# TODO: should packs also be non-writable on Windows? if so, that
+# would requite some rather significant adjustments to the test suite
+PACK_MODE = 0o444 if sys.platform != "win32" else 0o644
+
 
 class BaseObjectStore(object):
     """Object store interface."""
 
     def determine_wants_all(self, refs, depth=None):
         def _want_deepen(sha):
             if not depth:
                 return False
             if depth == DEPTH_INFINITE:
                 return True
             return depth > self._get_depth(sha)
 
         return [
             sha
             for (ref, sha) in refs.items()
             if (sha not in self or _want_deepen(sha))
             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 _get_depth(
         self, head, get_parents=lambda commit: commit.parents, max_depth=None,
     ):
         """Return the current available depth for the given head.
         For commits with multiple parents, the largest possible depth will be
         returned.
 
         Args:
             head: commit to start from
             get_parents: optional function for getting the parents of a commit
             max_depth: maximum depth to search
         """
         if head not in self:
             return 0
         current_depth = 1
         queue = [(head, current_depth)]
         while queue and (max_depth is None or current_depth < max_depth):
             e, depth = queue.pop(0)
             current_depth = max(current_depth, depth)
             cmt = self[e]
             if isinstance(cmt, Tag):
                 _cls, sha = cmt.object
                 cmt = self[sha]
             queue.extend(
                 (parent, depth + 1)
                 for parent in get_parents(cmt)
                 if parent in self
             )
         return current_depth
 
     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.startswith(b"#"):
                     continue
                 if os.path.isabs(line):
                     yield os.fsdecode(line)
                 else:
                     yield os.fsdecode(os.path.join(os.fsencode(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)):
                 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")
+        index_file = GitFile(pack_base_name + ".idx", "wb", mask=PACK_MODE)
         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.
         """
         import tempfile
 
         fd, path = tempfile.mkstemp(dir=self.path, prefix="tmp_pack_")
         with os.fdopen(fd, "w+b") as f:
+            os.chmod(path, PACK_MODE)
             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:
+                with GitFile(index_name, "wb", mask=PACK_MODE) 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.
         """
         import tempfile
 
         fd, path = tempfile.mkstemp(dir=self.pack_dir, suffix=".pack")
         f = os.fdopen(fd, "wb")
+        os.chmod(path, PACK_MODE)
 
         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:
+        with GitFile(path, "wb", mask=PACK_MODE) 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()
             try:
                 ps = self.get_parents(ret)
             except KeyError:
                 return None
             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)
 
 
 class BucketBasedObjectStore(PackBasedObjectStore):
     """Object store implementation that uses a bucket store like S3 as backend.
     """
 
     def _iter_loose_objects(self):
         """Iterate over the SHAs of all loose objects."""
         return iter([])
 
     def _get_loose_object(self, sha):
         return None
 
     def _remove_loose_object(self, sha):
         # Doesn't exist..
         pass
 
     def _remove_pack(self, name):
         raise NotImplementedError(self._remove_pack)
 
     def _iter_pack_names(self):
         raise NotImplementedError(self._iter_pack_names)
 
     def _get_pack(self, name):
         raise NotImplementedError(self._get_pack)
 
     def _update_pack_cache(self):
         pack_files = set(self._iter_pack_names())
 
         # Open newly appeared pack files
         new_packs = []
         for f in pack_files:
             if f not in self._pack_cache:
                 pack = self._get_pack(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 _upload_pack(self, basename, pack_file, index_file):
         raise NotImplementedError
 
     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.
         """
         import tempfile
 
         pf = tempfile.SpooledTemporaryFile()
 
         def commit():
             if pf.tell() == 0:
                 pf.close()
                 return None
 
             pf.seek(0)
             p = PackData(pf.name, pf)
             entries = p.sorted_entries()
             basename = iter_sha1(entry[0] for entry in entries).decode('ascii')
             idxf = tempfile.SpooledTemporaryFile()
             checksum = p.get_stored_checksum()
             write_pack_index_v2(idxf, entries, checksum)
             idxf.seek(0)
             idx = load_pack_index_file(basename + '.idx', idxf)
             for pack in self.packs:
                 if pack.get_stored_checksum() == p.get_stored_checksum():
                     p.close()
                     idx.close()
                     return pack
             pf.seek(0)
             idxf.seek(0)
             self._upload_pack(basename, pf, idxf)
             final_pack = Pack.from_objects(p, idx)
             self._add_cached_pack(basename, final_pack)
             return final_pack
 
         return pf, commit, pf.close
diff --git a/dulwich/porcelain.py b/dulwich/porcelain.py
index ea1722ed..e3cf4262 100644
--- a/dulwich/porcelain.py
+++ b/dulwich/porcelain.py
@@ -1,1924 +1,1933 @@
 # porcelain.py -- Porcelain-like layer on top of Dulwich
 # Copyright (C) 2013 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.
 #
 
 """Simple wrapper that provides porcelain-like functions on top of Dulwich.
 
 Currently implemented:
  * archive
  * add
  * branch{_create,_delete,_list}
  * check-ignore
  * checkout
  * clone
  * commit
  * commit-tree
  * daemon
  * describe
  * diff-tree
  * fetch
  * init
  * ls-files
  * ls-remote
  * ls-tree
  * pull
  * push
  * rm
  * remote{_add}
  * receive-pack
  * reset
  * rev-list
  * tag{_create,_delete,_list}
  * upload-pack
  * update-server-info
  * status
  * symbolic-ref
 
 These functions are meant to behave similarly to the git subcommands.
 Differences in behaviour are considered bugs.
 
 Functions should generally accept both unicode strings and bytestrings
 """
 
 from collections import namedtuple
 from contextlib import (
     closing,
     contextmanager,
 )
 from io import BytesIO, RawIOBase
 import datetime
 import os
 from pathlib import Path
 import posixpath
 import shutil
 import stat
 import sys
 import time
 from typing import (
     Dict,
     Optional,
     Tuple,
     Union,
 )
 
 from dulwich.archive import (
     tar_stream,
 )
 from dulwich.client import (
     get_transport_and_path,
 )
 from dulwich.config import (
     StackedConfig,
 )
 from dulwich.diff_tree import (
     CHANGE_ADD,
     CHANGE_DELETE,
     CHANGE_MODIFY,
     CHANGE_RENAME,
     CHANGE_COPY,
     RENAME_CHANGE_TYPES,
 )
 from dulwich.errors import (
     SendPackError,
 )
 from dulwich.graph import (
     can_fast_forward,
 )
 from dulwich.ignore import IgnoreFilterManager
 from dulwich.index import (
     blob_from_path_and_stat,
     get_unstaged_changes,
 )
 from dulwich.object_store import (
     tree_lookup_path,
 )
 from dulwich.objects import (
     Commit,
     Tag,
     format_timezone,
     parse_timezone,
     pretty_format_tree_entry,
 )
 from dulwich.objectspec import (
     parse_commit,
     parse_object,
     parse_ref,
     parse_reftuples,
     parse_tree,
 )
 from dulwich.pack import (
     write_pack_index,
     write_pack_objects,
 )
 from dulwich.patch import write_tree_diff
 from dulwich.protocol import (
     Protocol,
     ZERO_SHA,
 )
 from dulwich.refs import (
     ANNOTATED_TAG_SUFFIX,
     LOCAL_BRANCH_PREFIX,
     strip_peeled_refs,
     RefsContainer,
 )
 from dulwich.repo import BaseRepo, Repo
 from dulwich.server import (
     FileSystemBackend,
     TCPGitServer,
     ReceivePackHandler,
     UploadPackHandler,
     update_server_info as server_update_server_info,
 )
 
 
 # Module level tuple definition for status output
 GitStatus = namedtuple("GitStatus", "staged unstaged untracked")
 
 
 class NoneStream(RawIOBase):
     """Fallback if stdout or stderr are unavailable, does nothing."""
 
     def read(self, size=-1):
         return None
 
     def readall(self):
         return None
 
     def readinto(self, b):
         return None
 
     def write(self, b):
         return None
 
 
 default_bytes_out_stream = getattr(sys.stdout, "buffer", None) or NoneStream()
 default_bytes_err_stream = getattr(sys.stderr, "buffer", None) or NoneStream()
 
 
 DEFAULT_ENCODING = "utf-8"
 
 
 class Error(Exception):
     """Porcelain-based error. """
 
     def __init__(self, msg, inner=None):
         super(Error, self).__init__(msg)
         self.inner = inner
 
 
 class RemoteExists(Error):
     """Raised when the remote already exists."""
 
 
 def open_repo(path_or_repo):
     """Open an argument that can be a repository or a path for a repository."""
     if isinstance(path_or_repo, BaseRepo):
         return path_or_repo
     return Repo(path_or_repo)
 
 
 @contextmanager
 def _noop_context_manager(obj):
     """Context manager that has the same api as closing but does nothing."""
     yield obj
 
 
 def open_repo_closing(path_or_repo):
     """Open an argument that can be a repository or a path for a repository.
     returns a context manager that will close the repo on exit if the argument
     is a path, else does nothing if the argument is a repo.
     """
     if isinstance(path_or_repo, BaseRepo):
         return _noop_context_manager(path_or_repo)
     return closing(Repo(path_or_repo))
 
 
 def path_to_tree_path(repopath, path, tree_encoding=DEFAULT_ENCODING):
     """Convert a path to a path usable in an index, e.g. bytes and relative to
     the repository root.
 
     Args:
       repopath: Repository path, absolute or relative to the cwd
       path: A path, absolute or relative to the cwd
     Returns: A path formatted for use in e.g. an index
     """
     # Pathlib resolve before Python 3.6 could raises FileNotFoundError in case
     # there is no file matching the path so we reuse the old implementation for
     # Python 3.5
     if sys.version_info < (3, 6):
         if not isinstance(path, bytes):
             path = os.fsencode(path)
         if not isinstance(repopath, bytes):
             repopath = os.fsencode(repopath)
         treepath = os.path.relpath(path, repopath)
         if treepath.startswith(b".."):
             err_msg = "Path %r not in repo path (%r)" % (path, repopath)
             raise ValueError(err_msg)
         if os.path.sep != "/":
             treepath = treepath.replace(os.path.sep.encode("ascii"), b"/")
         return treepath
     else:
         # Resolve might returns a relative path on Windows
         # https://bugs.python.org/issue38671
         if sys.platform == "win32":
             path = os.path.abspath(path)
 
         path = Path(path)
         resolved_path = path.resolve()
 
         # Resolve and abspath seems to behave differently regarding symlinks,
         # as we are doing abspath on the file path, we need to do the same on
         # the repo path or they might not match
         if sys.platform == "win32":
             repopath = os.path.abspath(repopath)
 
         repopath = Path(repopath).resolve()
 
         try:
             relpath = resolved_path.relative_to(repopath)
         except ValueError:
             # If path is a symlink that points to a file outside the repo, we
             # want the relpath for the link itself, not the resolved target
             if path.is_symlink():
                 parent = path.parent.resolve()
                 relpath = (parent / path.name).relative_to(repopath)
             else:
                 raise
         if sys.platform == "win32":
             return str(relpath).replace(os.path.sep, "/").encode(tree_encoding)
         else:
             return bytes(relpath)
 
 
 class DivergedBranches(Error):
     """Branches have diverged and fast-forward is not possible."""
 
 
 def check_diverged(repo, current_sha, new_sha):
     """Check if updating to a sha can be done with fast forwarding.
 
     Args:
       repo: Repository object
       current_sha: Current head sha
       new_sha: New head sha
     """
     try:
         can = can_fast_forward(repo, current_sha, new_sha)
     except KeyError:
         can = False
     if not can:
         raise DivergedBranches(current_sha, new_sha)
 
 
 def archive(
     repo,
     committish=None,
     outstream=default_bytes_out_stream,
     errstream=default_bytes_err_stream,
 ):
     """Create an archive.
 
     Args:
       repo: Path of repository for which to generate an archive.
       committish: Commit SHA1 or ref to use
       outstream: Output stream (defaults to stdout)
       errstream: Error stream (defaults to stderr)
     """
 
     if committish is None:
         committish = "HEAD"
     with open_repo_closing(repo) as repo_obj:
         c = parse_commit(repo_obj, committish)
         for chunk in tar_stream(
             repo_obj.object_store, repo_obj.object_store[c.tree], c.commit_time
         ):
             outstream.write(chunk)
 
 
 def update_server_info(repo="."):
     """Update server info files for a repository.
 
     Args:
       repo: path to the repository
     """
     with open_repo_closing(repo) as r:
         server_update_server_info(r)
 
 
 def symbolic_ref(repo, ref_name, force=False):
     """Set git symbolic ref into HEAD.
 
     Args:
       repo: path to the repository
       ref_name: short name of the new ref
       force: force settings without checking if it exists in refs/heads
     """
     with open_repo_closing(repo) as repo_obj:
         ref_path = _make_branch_ref(ref_name)
         if not force and ref_path not in repo_obj.refs.keys():
             raise Error("fatal: ref `%s` is not a ref" % ref_name)
         repo_obj.refs.set_symbolic_ref(b"HEAD", ref_path)
 
 
 def commit(
     repo=".",
     message=None,
     author=None,
     committer=None,
     encoding=None,
     no_verify=False,
 ):
     """Create a new commit.
 
     Args:
       repo: Path to repository
       message: Optional commit message
       author: Optional author name and email
       committer: Optional committer name and email
       no_verify: Skip pre-commit and commit-msg hooks
     Returns: SHA1 of the new commit
     """
     # FIXME: Support --all argument
     # FIXME: Support --signoff argument
     if getattr(message, "encode", None):
         message = message.encode(encoding or DEFAULT_ENCODING)
     if getattr(author, "encode", None):
         author = author.encode(encoding or DEFAULT_ENCODING)
     if getattr(committer, "encode", None):
         committer = committer.encode(encoding or DEFAULT_ENCODING)
     with open_repo_closing(repo) as r:
         return r.do_commit(
             message=message,
             author=author,
             committer=committer,
             encoding=encoding,
             no_verify=no_verify,
         )
 
 
 def commit_tree(repo, tree, message=None, author=None, committer=None):
     """Create a new commit object.
 
     Args:
       repo: Path to repository
       tree: An existing tree object
       author: Optional author name and email
       committer: Optional committer name and email
     """
     with open_repo_closing(repo) as r:
         return r.do_commit(
             message=message, tree=tree, committer=committer, author=author
         )
 
 
 def init(path=".", bare=False):
     """Create a new git repository.
 
     Args:
       path: Path to repository.
       bare: Whether to create a bare repository.
     Returns: A Repo instance
     """
     if not os.path.exists(path):
         os.mkdir(path)
 
     if bare:
         return Repo.init_bare(path)
     else:
         return Repo.init(path)
 
 
 def clone(
     source,
     target=None,
     bare=False,
     checkout=None,
     errstream=default_bytes_err_stream,
     outstream=None,
     origin=b"origin",
     depth=None,
     **kwargs
 ):
     """Clone a local or remote git repository.
 
     Args:
       source: Path or URL for source repository
       target: Path to target repository (optional)
       bare: Whether or not to create a bare repository
       checkout: Whether or not to check-out HEAD after cloning
       errstream: Optional stream to write progress to
       outstream: Optional stream to write progress to (deprecated)
       origin: Name of remote from the repository used to clone
       depth: Depth to fetch at
     Returns: The new repository
     """
     # TODO(jelmer): This code overlaps quite a bit with Repo.clone
     if outstream is not None:
         import warnings
 
         warnings.warn(
             "outstream= has been deprecated in favour of errstream=.",
             DeprecationWarning,
             stacklevel=3,
         )
         errstream = outstream
 
     if checkout is None:
         checkout = not bare
     if checkout and bare:
         raise Error("checkout and bare are incompatible")
 
     if target is None:
         target = source.split("/")[-1]
 
     if not os.path.exists(target):
         os.mkdir(target)
 
     if bare:
         r = Repo.init_bare(target)
     else:
         r = Repo.init(target)
 
     reflog_message = b"clone: from " + source.encode("utf-8")
     try:
         target_config = r.get_config()
         if not isinstance(source, bytes):
             source = source.encode(DEFAULT_ENCODING)
         target_config.set((b"remote", origin), b"url", source)
         target_config.set(
             (b"remote", origin),
             b"fetch",
             b"+refs/heads/*:refs/remotes/" + origin + b"/*",
         )
         target_config.write_to_path()
         fetch_result = fetch(
             r,
             origin,
             errstream=errstream,
             message=reflog_message,
             depth=depth,
             **kwargs
         )
         for key, target in fetch_result.symrefs.items():
             r.refs.set_symbolic_ref(key, target)
         try:
             head = r[fetch_result.refs[b"HEAD"]]
         except KeyError:
             head = None
         else:
             r[b"HEAD"] = head.id
         if checkout and not bare and head is not None:
             errstream.write(b"Checking out " + head.id + b"\n")
             r.reset_index(head.tree)
     except BaseException:
         shutil.rmtree(target)
         r.close()
         raise
 
     return r
 
 
 def add(repo=".", paths=None):
     """Add files to the staging area.
 
     Args:
       repo: Repository for the files
       paths: Paths to add.  No value passed stages all modified files.
     Returns: Tuple with set of added files and ignored files
 
     If the repository contains ignored directories, the returned set will
     contain the path to an ignored directory (with trailing slash). Individual
     files within ignored directories will not be returned.
     """
     ignored = set()
     with open_repo_closing(repo) as r:
         repo_path = Path(r.path).resolve()
         ignore_manager = IgnoreFilterManager.from_repo(r)
         if not paths:
             paths = list(
                 get_untracked_paths(
                     str(Path(os.getcwd()).resolve()),
                     str(repo_path),
                     r.open_index(),
                 )
             )
         relpaths = []
         if not isinstance(paths, list):
             paths = [paths]
         for p in paths:
             path = Path(p)
             relpath = str(path.resolve().relative_to(repo_path))
             # FIXME: Support patterns
             if path.is_dir():
                 relpath = os.path.join(relpath, "")
             if ignore_manager.is_ignored(relpath):
                 ignored.add(relpath)
                 continue
             relpaths.append(relpath)
         r.stage(relpaths)
     return (relpaths, ignored)
 
 
 def _is_subdir(subdir, parentdir):
     """Check whether subdir is parentdir or a subdir of parentdir
 
     If parentdir or subdir is a relative path, it will be disamgibuated
     relative to the pwd.
     """
     parentdir_abs = os.path.realpath(parentdir) + os.path.sep
     subdir_abs = os.path.realpath(subdir) + os.path.sep
     return subdir_abs.startswith(parentdir_abs)
 
 
 # TODO: option to remove ignored files also, in line with `git clean -fdx`
 def clean(repo=".", target_dir=None):
     """Remove any untracked files from the target directory recursively
 
     Equivalent to running `git clean -fd` in target_dir.
 
     Args:
       repo: Repository where the files may be tracked
       target_dir: Directory to clean - current directory if None
     """
     if target_dir is None:
         target_dir = os.getcwd()
 
     with open_repo_closing(repo) as r:
         if not _is_subdir(target_dir, r.path):
             raise Error("target_dir must be in the repo's working dir")
 
         config = r.get_config_stack()
         require_force = config.get_boolean(  # noqa: F841
             (b"clean",), b"requireForce", True
         )
 
         # TODO(jelmer): if require_force is set, then make sure that -f, -i or
         # -n is specified.
 
         index = r.open_index()
         ignore_manager = IgnoreFilterManager.from_repo(r)
 
         paths_in_wd = _walk_working_dir_paths(target_dir, r.path)
         # Reverse file visit order, so that files and subdirectories are
         # removed before containing directory
         for ap, is_dir in reversed(list(paths_in_wd)):
             if is_dir:
                 # All subdirectories and files have been removed if untracked,
                 # so dir contains no tracked files iff it is empty.
                 is_empty = len(os.listdir(ap)) == 0
                 if is_empty:
                     os.rmdir(ap)
             else:
                 ip = path_to_tree_path(r.path, ap)
                 is_tracked = ip in index
 
                 rp = os.path.relpath(ap, r.path)
                 is_ignored = ignore_manager.is_ignored(rp)
 
                 if not is_tracked and not is_ignored:
                     os.remove(ap)
 
 
 def remove(repo=".", paths=None, cached=False):
     """Remove files from the staging area.
 
     Args:
       repo: Repository for the files
       paths: Paths to remove
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
         for p in paths:
             full_path = os.fsencode(os.path.abspath(p))
             tree_path = path_to_tree_path(r.path, p)
             try:
                 index_sha = index[tree_path].sha
             except KeyError:
                 raise Error("%s did not match any files" % p)
 
             if not cached:
                 try:
                     st = os.lstat(full_path)
                 except OSError:
                     pass
                 else:
                     try:
                         blob = blob_from_path_and_stat(full_path, st)
                     except IOError:
                         pass
                     else:
                         try:
                             committed_sha = tree_lookup_path(
                                 r.__getitem__, r[r.head()].tree, tree_path
                             )[1]
                         except KeyError:
                             committed_sha = None
 
                         if blob.id != index_sha and index_sha != committed_sha:
                             raise Error(
                                 "file has staged content differing "
                                 "from both the file and head: %s" % p
                             )
 
                         if index_sha != committed_sha:
                             raise Error("file has staged changes: %s" % p)
                         os.remove(full_path)
             del index[tree_path]
         index.write()
 
 
 rm = remove
 
 
 def commit_decode(commit, contents, default_encoding=DEFAULT_ENCODING):
     if commit.encoding:
         encoding = commit.encoding.decode("ascii")
     else:
         encoding = default_encoding
     return contents.decode(encoding, "replace")
 
 
 def commit_encode(commit, contents, default_encoding=DEFAULT_ENCODING):
     if commit.encoding:
         encoding = commit.encoding.decode("ascii")
     else:
         encoding = default_encoding
     return contents.encode(encoding)
 
 
 def print_commit(commit, decode, outstream=sys.stdout):
     """Write a human-readable commit log entry.
 
     Args:
       commit: A `Commit` object
       outstream: A stream file to write to
     """
     outstream.write("-" * 50 + "\n")
     outstream.write("commit: " + commit.id.decode("ascii") + "\n")
     if len(commit.parents) > 1:
         outstream.write(
             "merge: "
             + "...".join([c.decode("ascii") for c in commit.parents[1:]])
             + "\n"
         )
     outstream.write("Author: " + decode(commit.author) + "\n")
     if commit.author != commit.committer:
         outstream.write("Committer: " + decode(commit.committer) + "\n")
 
     time_tuple = time.gmtime(commit.author_time + commit.author_timezone)
     time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
     timezone_str = format_timezone(commit.author_timezone).decode("ascii")
     outstream.write("Date:   " + time_str + " " + timezone_str + "\n")
     outstream.write("\n")
     outstream.write(decode(commit.message) + "\n")
     outstream.write("\n")
 
 
 def print_tag(tag, decode, outstream=sys.stdout):
     """Write a human-readable tag.
 
     Args:
       tag: A `Tag` object
       decode: Function for decoding bytes to unicode string
       outstream: A stream to write to
     """
     outstream.write("Tagger: " + decode(tag.tagger) + "\n")
     time_tuple = time.gmtime(tag.tag_time + tag.tag_timezone)
     time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
     timezone_str = format_timezone(tag.tag_timezone).decode("ascii")
     outstream.write("Date:   " + time_str + " " + timezone_str + "\n")
     outstream.write("\n")
     outstream.write(decode(tag.message))
     outstream.write("\n")
 
 
 def show_blob(repo, blob, decode, outstream=sys.stdout):
     """Write a blob to a stream.
 
     Args:
       repo: A `Repo` object
       blob: A `Blob` object
       decode: Function for decoding bytes to unicode string
       outstream: A stream file to write to
     """
     outstream.write(decode(blob.data))
 
 
 def show_commit(repo, commit, decode, outstream=sys.stdout):
     """Show a commit to a stream.
 
     Args:
       repo: A `Repo` object
       commit: A `Commit` object
       decode: Function for decoding bytes to unicode string
       outstream: Stream to write to
     """
     print_commit(commit, decode=decode, outstream=outstream)
     if commit.parents:
         parent_commit = repo[commit.parents[0]]
         base_tree = parent_commit.tree
     else:
         base_tree = None
     diffstream = BytesIO()
     write_tree_diff(diffstream, repo.object_store, base_tree, commit.tree)
     diffstream.seek(0)
     outstream.write(commit_decode(commit, diffstream.getvalue()))
 
 
 def show_tree(repo, tree, decode, outstream=sys.stdout):
     """Print a tree to a stream.
 
     Args:
       repo: A `Repo` object
       tree: A `Tree` object
       decode: Function for decoding bytes to unicode string
       outstream: Stream to write to
     """
     for n in tree:
         outstream.write(decode(n) + "\n")
 
 
 def show_tag(repo, tag, decode, outstream=sys.stdout):
     """Print a tag to a stream.
 
     Args:
       repo: A `Repo` object
       tag: A `Tag` object
       decode: Function for decoding bytes to unicode string
       outstream: Stream to write to
     """
     print_tag(tag, decode, outstream)
     show_object(repo, repo[tag.object[1]], decode, outstream)
 
 
 def show_object(repo, obj, decode, outstream):
     return {
         b"tree": show_tree,
         b"blob": show_blob,
         b"commit": show_commit,
         b"tag": show_tag,
     }[obj.type_name](repo, obj, decode, outstream)
 
 
 def print_name_status(changes):
     """Print a simple status summary, listing changed files."""
     for change in changes:
         if not change:
             continue
         if isinstance(change, list):
             change = change[0]
         if change.type == CHANGE_ADD:
             path1 = change.new.path
             path2 = ""
             kind = "A"
         elif change.type == CHANGE_DELETE:
             path1 = change.old.path
             path2 = ""
             kind = "D"
         elif change.type == CHANGE_MODIFY:
             path1 = change.new.path
             path2 = ""
             kind = "M"
         elif change.type in RENAME_CHANGE_TYPES:
             path1 = change.old.path
             path2 = change.new.path
             if change.type == CHANGE_RENAME:
                 kind = "R"
             elif change.type == CHANGE_COPY:
                 kind = "C"
         yield "%-8s%-20s%-20s" % (kind, path1, path2)
 
 
 def log(
     repo=".",
     paths=None,
     outstream=sys.stdout,
     max_entries=None,
     reverse=False,
     name_status=False,
 ):
     """Write commit logs.
 
     Args:
       repo: Path to repository
       paths: Optional set of specific paths to print entries for
       outstream: Stream to write log output to
       reverse: Reverse order in which entries are printed
       name_status: Print name status
       max_entries: Optional maximum number of entries to display
     """
     with open_repo_closing(repo) as r:
         walker = r.get_walker(max_entries=max_entries, paths=paths, reverse=reverse)
         for entry in walker:
 
             def decode(x):
                 return commit_decode(entry.commit, x)
 
             print_commit(entry.commit, decode, outstream)
             if name_status:
                 outstream.writelines(
                     [line + "\n" for line in print_name_status(entry.changes())]
                 )
 
 
 # TODO(jelmer): better default for encoding?
 def show(
     repo=".",
     objects=None,
     outstream=sys.stdout,
     default_encoding=DEFAULT_ENCODING,
 ):
     """Print the changes in a commit.
 
     Args:
       repo: Path to repository
       objects: Objects to show (defaults to [HEAD])
       outstream: Stream to write to
       default_encoding: Default encoding to use if none is set in the
         commit
     """
     if objects is None:
         objects = ["HEAD"]
     if not isinstance(objects, list):
         objects = [objects]
     with open_repo_closing(repo) as r:
         for objectish in objects:
             o = parse_object(r, objectish)
             if isinstance(o, Commit):
 
                 def decode(x):
                     return commit_decode(o, x, default_encoding)
 
             else:
 
                 def decode(x):
                     return x.decode(default_encoding)
 
             show_object(r, o, decode, outstream)
 
 
 def diff_tree(repo, old_tree, new_tree, outstream=sys.stdout):
     """Compares the content and mode of blobs found via two tree objects.
 
     Args:
       repo: Path to repository
       old_tree: Id of old tree
       new_tree: Id of new tree
       outstream: Stream to write to
     """
     with open_repo_closing(repo) as r:
         write_tree_diff(outstream, r.object_store, old_tree, new_tree)
 
 
 def rev_list(repo, commits, outstream=sys.stdout):
     """Lists commit objects in reverse chronological order.
 
     Args:
       repo: Path to repository
       commits: Commits over which to iterate
       outstream: Stream to write to
     """
     with open_repo_closing(repo) as r:
         for entry in r.get_walker(include=[r[c].id for c in commits]):
             outstream.write(entry.commit.id + b"\n")
 
 
 def tag(*args, **kwargs):
     import warnings
 
     warnings.warn(
         "tag has been deprecated in favour of tag_create.", DeprecationWarning
     )
     return tag_create(*args, **kwargs)
 
 
 def tag_create(
     repo,
     tag,
     author=None,
     message=None,
     annotated=False,
     objectish="HEAD",
     tag_time=None,
     tag_timezone=None,
     sign=False,
 ):
     """Creates a tag in git via dulwich calls:
 
     Args:
       repo: Path to repository
       tag: tag string
       author: tag author (optional, if annotated is set)
       message: tag message (optional)
       annotated: whether to create an annotated tag
       objectish: object the tag should point at, defaults to HEAD
       tag_time: Optional time for annotated tag
       tag_timezone: Optional timezone for annotated tag
       sign: GPG Sign the tag (bool, defaults to False,
         pass True to use default GPG key,
         pass a str containing Key ID to use a specific GPG key)
     """
 
     with open_repo_closing(repo) as r:
         object = parse_object(r, objectish)
 
         if annotated:
             # Create the tag object
             tag_obj = Tag()
             if author is None:
                 # TODO(jelmer): Don't use repo private method.
                 author = r._get_user_identity(r.get_config_stack())
             tag_obj.tagger = author
             tag_obj.message = message + "\n".encode()
             tag_obj.name = tag
             tag_obj.object = (type(object), object.id)
             if tag_time is None:
                 tag_time = int(time.time())
             tag_obj.tag_time = tag_time
             if tag_timezone is None:
                 # TODO(jelmer) Use current user timezone rather than UTC
                 tag_timezone = 0
             elif isinstance(tag_timezone, str):
                 tag_timezone = parse_timezone(tag_timezone)
             tag_obj.tag_timezone = tag_timezone
             if sign:
                 tag_obj.sign(sign if isinstance(sign, str) else None)
 
             r.object_store.add_object(tag_obj)
             tag_id = tag_obj.id
         else:
             tag_id = object.id
 
         r.refs[_make_tag_ref(tag)] = tag_id
 
 
 def list_tags(*args, **kwargs):
     import warnings
 
     warnings.warn(
         "list_tags has been deprecated in favour of tag_list.",
         DeprecationWarning,
     )
     return tag_list(*args, **kwargs)
 
 
 def tag_list(repo, outstream=sys.stdout):
     """List all tags.
 
     Args:
       repo: Path to repository
       outstream: Stream to write tags to
     """
     with open_repo_closing(repo) as r:
         tags = sorted(r.refs.as_dict(b"refs/tags"))
         return tags
 
 
 def tag_delete(repo, name):
     """Remove a tag.
 
     Args:
       repo: Path to repository
       name: Name of tag to remove
     """
     with open_repo_closing(repo) as r:
         if isinstance(name, bytes):
             names = [name]
         elif isinstance(name, list):
             names = name
         else:
             raise Error("Unexpected tag name type %r" % name)
         for name in names:
             del r.refs[_make_tag_ref(name)]
 
 
 def reset(repo, mode, treeish="HEAD"):
     """Reset current HEAD to the specified state.
 
     Args:
       repo: Path to repository
       mode: Mode ("hard", "soft", "mixed")
       treeish: Treeish to reset to
     """
 
     if mode != "hard":
         raise Error("hard is the only mode currently supported")
 
     with open_repo_closing(repo) as r:
         tree = parse_tree(r, treeish)
         r.reset_index(tree.id)
 
 
 def get_remote_repo(
     repo: Repo, remote_location: Optional[Union[str, bytes]] = None
 ) -> Tuple[Optional[str], str]:
     config = repo.get_config()
     if remote_location is None:
         remote_location = get_branch_remote(repo)
     if isinstance(remote_location, str):
         encoded_location = remote_location.encode()
     else:
         encoded_location = remote_location
 
     section = (b"remote", encoded_location)
 
     remote_name = None  # type: Optional[str]
 
     if config.has_section(section):
         remote_name = encoded_location.decode()
         url = config.get(section, "url")
         encoded_location = url
     else:
         remote_name = None
 
     return (remote_name, encoded_location.decode())
 
 
 def push(
     repo,
     remote_location=None,
     refspecs=None,
     outstream=default_bytes_out_stream,
     errstream=default_bytes_err_stream,
     force=False,
     **kwargs
 ):
     """Remote push with dulwich via dulwich.client
 
     Args:
       repo: Path to repository
       remote_location: Location of the remote
       refspecs: Refs to push to remote
       outstream: A stream file to write output
       errstream: A stream file to write errors
       force: Force overwriting refs
     """
 
     # Open the repo
     with open_repo_closing(repo) as r:
         if refspecs is None:
             refspecs = [active_branch(r)]
         (remote_name, remote_location) = get_remote_repo(r, remote_location)
 
         # Get the client and path
         client, path = get_transport_and_path(
             remote_location, config=r.get_config_stack(), **kwargs
         )
 
         selected_refs = []
         remote_changed_refs = {}
 
         def update_refs(refs):
             selected_refs.extend(parse_reftuples(r.refs, refs, refspecs, force=force))
             new_refs = {}
             # TODO: Handle selected_refs == {None: None}
             for (lh, rh, force_ref) in selected_refs:
                 if lh is None:
                     new_refs[rh] = ZERO_SHA
                     remote_changed_refs[rh] = None
                 else:
                     try:
                         localsha = r.refs[lh]
                     except KeyError:
                         raise Error("No valid ref %s in local repository" % lh)
                     if not force_ref and rh in refs:
                         check_diverged(r, refs[rh], localsha)
                     new_refs[rh] = localsha
                     remote_changed_refs[rh] = localsha
             return new_refs
 
         err_encoding = getattr(errstream, "encoding", None) or DEFAULT_ENCODING
         remote_location = client.get_url(path)
         try:
             result = client.send_pack(
                 path,
                 update_refs,
                 generate_pack_data=r.generate_pack_data,
                 progress=errstream.write,
             )
         except SendPackError as e:
             raise Error(
                 "Push to " + remote_location + " failed -> " + e.args[0].decode(),
                 inner=e,
             )
         else:
             errstream.write(
                 b"Push to " + remote_location.encode(err_encoding) + b" successful.\n"
             )
 
         for ref, error in (result.ref_status or {}).items():
             if error is not None:
                 errstream.write(
                     b"Push of ref %s failed: %s\n" % (ref, error.encode(err_encoding))
                 )
             else:
                 errstream.write(b"Ref %s updated\n" % ref)
 
         if remote_name is not None:
             _import_remote_refs(r.refs, remote_name, remote_changed_refs)
 
 
 def pull(
     repo,
     remote_location=None,
     refspecs=None,
     outstream=default_bytes_out_stream,
     errstream=default_bytes_err_stream,
     fast_forward=True,
     force=False,
     **kwargs
 ):
     """Pull from remote via dulwich.client
 
     Args:
       repo: Path to repository
       remote_location: Location of the remote
       refspec: refspecs to fetch
       outstream: A stream file to write to output
       errstream: A stream file to write to errors
     """
     # Open the repo
     with open_repo_closing(repo) as r:
         (remote_name, remote_location) = get_remote_repo(r, remote_location)
 
         if refspecs is None:
             refspecs = [b"HEAD"]
         selected_refs = []
 
         def determine_wants(remote_refs, **kwargs):
             selected_refs.extend(
                 parse_reftuples(remote_refs, r.refs, refspecs, force=force)
             )
             return [
                 remote_refs[lh]
                 for (lh, rh, force_ref) in selected_refs
                 if remote_refs[lh] not in r.object_store
             ]
 
         client, path = get_transport_and_path(
             remote_location, config=r.get_config_stack(), **kwargs
         )
         fetch_result = client.fetch(
             path, r, progress=errstream.write, determine_wants=determine_wants
         )
         for (lh, rh, force_ref) in selected_refs:
             try:
                 check_diverged(r, r.refs[rh], fetch_result.refs[lh])
             except DivergedBranches:
                 if fast_forward:
                     raise
                 else:
                     raise NotImplementedError("merge is not yet supported")
             r.refs[rh] = fetch_result.refs[lh]
         if selected_refs:
             r[b"HEAD"] = fetch_result.refs[selected_refs[0][1]]
 
         # Perform 'git checkout .' - syncs staged changes
         tree = r[b"HEAD"].tree
         r.reset_index(tree=tree)
         if remote_name is not None:
             _import_remote_refs(r.refs, remote_name, fetch_result.refs)
 
 
 def status(repo=".", ignored=False):
     """Returns staged, unstaged, and untracked changes relative to the HEAD.
 
     Args:
       repo: Path to repository or repository object
       ignored: Whether to include ignored files in `untracked`
     Returns: GitStatus tuple,
         staged -  dict with lists of staged paths (diff index/HEAD)
         unstaged -  list of unstaged paths (diff index/working-tree)
         untracked - list of untracked, un-ignored & non-.git paths
     """
     with open_repo_closing(repo) as r:
         # 1. Get status of staged
         tracked_changes = get_tree_changes(r)
         # 2. Get status of unstaged
         index = r.open_index()
         normalizer = r.get_blob_normalizer()
         filter_callback = normalizer.checkin_normalize
         unstaged_changes = list(get_unstaged_changes(index, r.path, filter_callback))
 
         untracked_paths = get_untracked_paths(
             r.path, r.path, index, exclude_ignored=not ignored
         )
         untracked_changes = list(untracked_paths)
 
         return GitStatus(tracked_changes, unstaged_changes, untracked_changes)
 
 
 def _walk_working_dir_paths(frompath, basepath, prune_dirnames=None):
     """Get path, is_dir for files in working dir from frompath
 
     Args:
       frompath: Path to begin walk
       basepath: Path to compare to
       prune_dirnames: Optional callback to prune dirnames during os.walk
         dirnames will be set to result of prune_dirnames(dirpath, dirnames)
     """
     for dirpath, dirnames, filenames in os.walk(frompath):
         # Skip .git and below.
         if ".git" in dirnames:
             dirnames.remove(".git")
             if dirpath != basepath:
                 continue
 
         if ".git" in filenames:
             filenames.remove(".git")
             if dirpath != basepath:
                 continue
 
         if dirpath != frompath:
             yield dirpath, True
 
         for filename in filenames:
             filepath = os.path.join(dirpath, filename)
             yield filepath, False
 
         if prune_dirnames:
             dirnames[:] = prune_dirnames(dirpath, dirnames)
 
 
 def get_untracked_paths(frompath, basepath, index, exclude_ignored=False):
     """Get untracked paths.
 
     Args:
       frompath: Path to walk
       basepath: Path to compare to
       index: Index to check against
       exclude_ignored: Whether to exclude ignored paths
 
     Note: ignored directories will never be walked for performance reasons.
       If exclude_ignored is False, only the path to an ignored directory will
       be yielded, no files inside the directory will be returned
     """
     with open_repo_closing(basepath) as r:
         ignore_manager = IgnoreFilterManager.from_repo(r)
 
     ignored_dirs = []
 
     def prune_dirnames(dirpath, dirnames):
         for i in range(len(dirnames) - 1, -1, -1):
             path = os.path.join(dirpath, dirnames[i])
             ip = os.path.join(os.path.relpath(path, basepath), "")
             if ignore_manager.is_ignored(ip):
                 if not exclude_ignored:
                     ignored_dirs.append(
                         os.path.join(os.path.relpath(path, frompath), "")
                     )
                 del dirnames[i]
         return dirnames
 
     for ap, is_dir in _walk_working_dir_paths(
         frompath, basepath, prune_dirnames=prune_dirnames
     ):
         if not is_dir:
             ip = path_to_tree_path(basepath, ap)
             if ip not in index:
                 if (
                     not exclude_ignored
                     or not ignore_manager.is_ignored(
                         os.path.relpath(ap, basepath)
                     )
                 ):
                     yield os.path.relpath(ap, frompath)
 
     yield from ignored_dirs
 
 
 def get_tree_changes(repo):
     """Return add/delete/modify changes to tree by comparing index to HEAD.
 
     Args:
       repo: repo path or object
     Returns: dict with lists for each type of change
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
 
         # Compares the Index to the HEAD & determines changes
         # Iterate through the changes and report add/delete/modify
         # TODO: call out to dulwich.diff_tree somehow.
         tracked_changes = {
             "add": [],
             "delete": [],
             "modify": [],
         }
         try:
             tree_id = r[b"HEAD"].tree
         except KeyError:
             tree_id = None
 
         for change in index.changes_from_tree(r.object_store, tree_id):
             if not change[0][0]:
                 tracked_changes["add"].append(change[0][1])
             elif not change[0][1]:
                 tracked_changes["delete"].append(change[0][0])
             elif change[0][0] == change[0][1]:
                 tracked_changes["modify"].append(change[0][0])
             else:
                 raise NotImplementedError("git mv ops not yet supported")
         return tracked_changes
 
 
 def daemon(path=".", address=None, port=None):
     """Run a daemon serving Git requests over TCP/IP.
 
     Args:
       path: Path to the directory to serve.
       address: Optional address to listen on (defaults to ::)
       port: Optional port to listen on (defaults to TCP_GIT_PORT)
     """
     # TODO(jelmer): Support git-daemon-export-ok and --export-all.
     backend = FileSystemBackend(path)
     server = TCPGitServer(backend, address, port)
     server.serve_forever()
 
 
 def web_daemon(path=".", address=None, port=None):
     """Run a daemon serving Git requests over HTTP.
 
     Args:
       path: Path to the directory to serve
       address: Optional address to listen on (defaults to ::)
       port: Optional port to listen on (defaults to 80)
     """
     from dulwich.web import (
         make_wsgi_chain,
         make_server,
         WSGIRequestHandlerLogger,
         WSGIServerLogger,
     )
 
     backend = FileSystemBackend(path)
     app = make_wsgi_chain(backend)
     server = make_server(
         address,
         port,
         app,
         handler_class=WSGIRequestHandlerLogger,
         server_class=WSGIServerLogger,
     )
     server.serve_forever()
 
 
 def upload_pack(path=".", inf=None, outf=None):
     """Upload a pack file after negotiating its contents using smart protocol.
 
     Args:
       path: Path to the repository
       inf: Input stream to communicate with client
       outf: Output stream to communicate with client
     """
     if outf is None:
         outf = getattr(sys.stdout, "buffer", sys.stdout)
     if inf is None:
         inf = getattr(sys.stdin, "buffer", sys.stdin)
     path = os.path.expanduser(path)
     backend = FileSystemBackend(path)
 
     def send_fn(data):
         outf.write(data)
         outf.flush()
 
     proto = Protocol(inf.read, send_fn)
     handler = UploadPackHandler(backend, [path], proto)
     # FIXME: Catch exceptions and write a single-line summary to outf.
     handler.handle()
     return 0
 
 
 def receive_pack(path=".", inf=None, outf=None):
     """Receive a pack file after negotiating its contents using smart protocol.
 
     Args:
       path: Path to the repository
       inf: Input stream to communicate with client
       outf: Output stream to communicate with client
     """
     if outf is None:
         outf = getattr(sys.stdout, "buffer", sys.stdout)
     if inf is None:
         inf = getattr(sys.stdin, "buffer", sys.stdin)
     path = os.path.expanduser(path)
     backend = FileSystemBackend(path)
 
     def send_fn(data):
         outf.write(data)
         outf.flush()
 
     proto = Protocol(inf.read, send_fn)
     handler = ReceivePackHandler(backend, [path], proto)
     # FIXME: Catch exceptions and write a single-line summary to outf.
     handler.handle()
     return 0
 
 
 def _make_branch_ref(name):
     if getattr(name, "encode", None):
         name = name.encode(DEFAULT_ENCODING)
     return LOCAL_BRANCH_PREFIX + name
 
 
 def _make_tag_ref(name):
     if getattr(name, "encode", None):
         name = name.encode(DEFAULT_ENCODING)
     return b"refs/tags/" + name
 
 
 def branch_delete(repo, name):
     """Delete a branch.
 
     Args:
       repo: Path to the repository
       name: Name of the branch
     """
     with open_repo_closing(repo) as r:
         if isinstance(name, list):
             names = name
         else:
             names = [name]
         for name in names:
             del r.refs[_make_branch_ref(name)]
 
 
 def branch_create(repo, name, objectish=None, force=False):
     """Create a branch.
 
     Args:
       repo: Path to the repository
       name: Name of the new branch
       objectish: Target object to point new branch at (defaults to HEAD)
       force: Force creation of branch, even if it already exists
     """
     with open_repo_closing(repo) as r:
         if objectish is None:
             objectish = "HEAD"
         object = parse_object(r, objectish)
         refname = _make_branch_ref(name)
         ref_message = b"branch: Created from " + objectish.encode("utf-8")
         if force:
             r.refs.set_if_equals(refname, None, object.id, message=ref_message)
         else:
             if not r.refs.add_if_new(refname, object.id, message=ref_message):
                 raise Error("Branch with name %s already exists." % name)
 
 
 def branch_list(repo):
     """List all branches.
 
     Args:
       repo: Path to the repository
     """
     with open_repo_closing(repo) as r:
         return r.refs.keys(base=LOCAL_BRANCH_PREFIX)
 
 
 def active_branch(repo):
     """Return the active branch in the repository, if any.
 
     Args:
       repo: Repository to open
     Returns:
       branch name
     Raises:
       KeyError: if the repository does not have a working tree
       IndexError: if HEAD is floating
     """
     with open_repo_closing(repo) as r:
         active_ref = r.refs.follow(b"HEAD")[0][1]
         if not active_ref.startswith(LOCAL_BRANCH_PREFIX):
             raise ValueError(active_ref)
         return active_ref[len(LOCAL_BRANCH_PREFIX) :]
 
 
 def get_branch_remote(repo):
     """Return the active branch's remote name, if any.
 
     Args:
       repo: Repository to open
     Returns:
       remote name
     Raises:
       KeyError: if the repository does not have a working tree
     """
     with open_repo_closing(repo) as r:
         branch_name = active_branch(r.path)
         config = r.get_config()
         try:
             remote_name = config.get((b"branch", branch_name), b"remote")
         except KeyError:
             remote_name = b"origin"
     return remote_name
 
 
 def _import_remote_refs(
     refs_container: RefsContainer,
     remote_name: str,
     refs: Dict[str, str],
     message: Optional[bytes] = None,
     prune: bool = False,
     prune_tags: bool = False,
 ):
     stripped_refs = strip_peeled_refs(refs)
     branches = {
         n[len(LOCAL_BRANCH_PREFIX) :]: v
         for (n, v) in stripped_refs.items()
         if n.startswith(LOCAL_BRANCH_PREFIX)
     }
     refs_container.import_refs(
         b"refs/remotes/" + remote_name.encode(),
         branches,
         message=message,
         prune=prune,
     )
     tags = {
         n[len(b"refs/tags/") :]: v
         for (n, v) in stripped_refs.items()
         if n.startswith(b"refs/tags/") and not n.endswith(ANNOTATED_TAG_SUFFIX)
     }
     refs_container.import_refs(b"refs/tags", tags, message=message, prune=prune_tags)
 
 
 def fetch(
     repo,
     remote_location=None,
     outstream=sys.stdout,
     errstream=default_bytes_err_stream,
     message=None,
     depth=None,
     prune=False,
     prune_tags=False,
     force=False,
     **kwargs
 ):
     """Fetch objects from a remote server.
 
     Args:
       repo: Path to the repository
       remote_location: String identifying a remote server
       outstream: Output stream (defaults to stdout)
       errstream: Error stream (defaults to stderr)
       message: Reflog message (defaults to b"fetch: from <remote_name>")
       depth: Depth to fetch at
       prune: Prune remote removed refs
       prune_tags: Prune reomte removed tags
     Returns:
       Dictionary with refs on the remote
     """
     with open_repo_closing(repo) as r:
         (remote_name, remote_location) = get_remote_repo(r, remote_location)
         if message is None:
             message = b"fetch: from " + remote_location.encode("utf-8")
         client, path = get_transport_and_path(
             remote_location, config=r.get_config_stack(), **kwargs
         )
         fetch_result = client.fetch(path, r, progress=errstream.write, depth=depth)
         if remote_name is not None:
             _import_remote_refs(
                 r.refs,
                 remote_name,
                 fetch_result.refs,
                 message,
                 prune=prune,
                 prune_tags=prune_tags,
             )
     return fetch_result
 
 
 def ls_remote(remote, config=None, **kwargs):
     """List the refs in a remote.
 
     Args:
       remote: Remote repository location
       config: Configuration to use
     Returns:
       Dictionary with remote refs
     """
     if config is None:
         config = StackedConfig.default()
     client, host_path = get_transport_and_path(remote, config=config, **kwargs)
     return client.get_refs(host_path)
 
 
 def repack(repo):
     """Repack loose files in a repository.
 
     Currently this only packs loose objects.
 
     Args:
       repo: Path to the repository
     """
     with open_repo_closing(repo) as r:
         r.object_store.pack_loose_objects()
 
 
 def pack_objects(repo, object_ids, packf, idxf, delta_window_size=None):
     """Pack objects into a file.
 
     Args:
       repo: Path to the repository
       object_ids: List of object ids to write
       packf: File-like object to write to
       idxf: File-like object to write to (can be None)
     """
     with open_repo_closing(repo) as r:
         entries, data_sum = write_pack_objects(
             packf,
             r.object_store.iter_shas((oid, None) for oid in object_ids),
             delta_window_size=delta_window_size,
         )
     if idxf is not None:
         entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
         write_pack_index(idxf, entries, data_sum)
 
 
 def ls_tree(
     repo,
     treeish=b"HEAD",
     outstream=sys.stdout,
     recursive=False,
     name_only=False,
 ):
     """List contents of a tree.
 
     Args:
       repo: Path to the repository
       tree_ish: Tree id to list
       outstream: Output stream (defaults to stdout)
       recursive: Whether to recursively list files
       name_only: Only print item name
     """
 
     def list_tree(store, treeid, base):
         for (name, mode, sha) in store[treeid].iteritems():
             if base:
                 name = posixpath.join(base, name)
             if name_only:
                 outstream.write(name + b"\n")
             else:
                 outstream.write(pretty_format_tree_entry(name, mode, sha))
             if stat.S_ISDIR(mode) and recursive:
                 list_tree(store, sha, name)
 
     with open_repo_closing(repo) as r:
         tree = parse_tree(r, treeish)
         list_tree(r.object_store, tree.id, "")
 
 
 def remote_add(repo, name, url):
     """Add a remote.
 
     Args:
       repo: Path to the repository
       name: Remote name
       url: Remote URL
     """
     if not isinstance(name, bytes):
         name = name.encode(DEFAULT_ENCODING)
     if not isinstance(url, bytes):
         url = url.encode(DEFAULT_ENCODING)
     with open_repo_closing(repo) as r:
         c = r.get_config()
         section = (b"remote", name)
         if c.has_section(section):
             raise RemoteExists(section)
         c.set(section, b"url", url)
         c.write_to_path()
 
 
 def check_ignore(repo, paths, no_index=False):
     """Debug gitignore files.
 
     Args:
       repo: Path to the repository
       paths: List of paths to check for
       no_index: Don't check index
     Returns: List of ignored files
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
         ignore_manager = IgnoreFilterManager.from_repo(r)
         for path in paths:
             if not no_index and path_to_tree_path(r.path, path) in index:
                 continue
             if os.path.isabs(path):
                 path = os.path.relpath(path, r.path)
             if ignore_manager.is_ignored(path):
                 yield path
 
 
 def update_head(repo, target, detached=False, new_branch=None):
     """Update HEAD to point at a new branch/commit.
 
     Note that this does not actually update the working tree.
 
     Args:
       repo: Path to the repository
       detach: Create a detached head
       target: Branch or committish to switch to
       new_branch: New branch to create
     """
     with open_repo_closing(repo) as r:
         if new_branch is not None:
             to_set = _make_branch_ref(new_branch)
         else:
             to_set = b"HEAD"
         if detached:
             # TODO(jelmer): Provide some way so that the actual ref gets
             # updated rather than what it points to, so the delete isn't
             # necessary.
             del r.refs[to_set]
             r.refs[to_set] = parse_commit(r, target).id
         else:
             r.refs.set_symbolic_ref(to_set, parse_ref(r, target))
         if new_branch is not None:
             r.refs.set_symbolic_ref(b"HEAD", to_set)
 
 
 def check_mailmap(repo, contact):
     """Check canonical name and email of contact.
 
     Args:
       repo: Path to the repository
       contact: Contact name and/or email
     Returns: Canonical contact data
     """
     with open_repo_closing(repo) as r:
         from dulwich.mailmap import Mailmap
 
         try:
             mailmap = Mailmap.from_path(os.path.join(r.path, ".mailmap"))
         except FileNotFoundError:
             mailmap = Mailmap()
         return mailmap.lookup(contact)
 
 
 def fsck(repo):
     """Check a repository.
 
     Args:
       repo: A path to the repository
     Returns: Iterator over errors/warnings
     """
     with open_repo_closing(repo) as r:
         # TODO(jelmer): check pack files
         # TODO(jelmer): check graph
         # TODO(jelmer): check refs
         for sha in r.object_store:
             o = r.object_store[sha]
             try:
                 o.check()
             except Exception as e:
                 yield (sha, e)
 
 
 def stash_list(repo):
     """List all stashes in a repository."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
         return enumerate(list(stash.stashes()))
 
 
 def stash_push(repo):
     """Push a new stash onto the stack."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
         stash.push()
 
 
-def stash_pop(repo):
-    """Pop a new stash from the stack."""
+def stash_pop(repo, index):
+    """Pop a stash from the stack."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
-        stash.pop()
+        stash.pop(index)
+
+
+def stash_drop(repo, index):
+    """Drop a stash from the stack."""
+    with open_repo_closing(repo) as r:
+        from dulwich.stash import Stash
+
+        stash = Stash.from_repo(r)
+        stash.drop(index)
 
 
 def ls_files(repo):
     """List all files in an index."""
     with open_repo_closing(repo) as r:
         return sorted(r.open_index())
 
 
 def describe(repo):
     """Describe the repository version.
 
     Args:
       projdir: git repository root
     Returns: a string description of the current git revision
 
     Examples: "gabcdefh", "v0.1" or "v0.1-5-gabcdefh".
     """
     # Get the repository
     with open_repo_closing(repo) as r:
         # Get a list of all tags
         refs = r.get_refs()
         tags = {}
         for key, value in refs.items():
             key = key.decode()
             obj = r.get_object(value)
             if u"tags" not in key:
                 continue
 
             _, tag = key.rsplit(u"/", 1)
 
             try:
                 commit = obj.object
             except AttributeError:
                 continue
             else:
                 commit = r.get_object(commit[1])
             tags[tag] = [
                 datetime.datetime(*time.gmtime(commit.commit_time)[:6]),
                 commit.id.decode("ascii"),
             ]
 
         sorted_tags = sorted(tags.items(), key=lambda tag: tag[1][0], reverse=True)
 
         # If there are no tags, return the current commit
         if len(sorted_tags) == 0:
             return "g{}".format(r[r.head()].id.decode("ascii")[:7])
 
         # We're now 0 commits from the top
         commit_count = 0
 
         # Get the latest commit
         latest_commit = r[r.head()]
 
         # Walk through all commits
         walker = r.get_walker()
         for entry in walker:
             # Check if tag
             commit_id = entry.commit.id.decode("ascii")
             for tag in sorted_tags:
                 tag_name = tag[0]
                 tag_commit = tag[1][1]
                 if commit_id == tag_commit:
                     if commit_count == 0:
                         return tag_name
                     else:
                         return "{}-{}-g{}".format(
                             tag_name,
                             commit_count,
                             latest_commit.id.decode("ascii")[:7],
                         )
 
             commit_count += 1
 
         # Return plain commit if no parent tag can be found
         return "g{}".format(latest_commit.id.decode("ascii")[:7])
 
 
 def get_object_by_path(repo, path, committish=None):
     """Get an object by path.
 
     Args:
       repo: A path to the repository
       path: Path to look up
       committish: Commit to look up path in
     Returns: A `ShaFile` object
     """
     if committish is None:
         committish = "HEAD"
     # Get the repository
     with open_repo_closing(repo) as r:
         commit = parse_commit(r, committish)
         base_tree = commit.tree
         if not isinstance(path, bytes):
             path = commit_encode(commit, path)
         (mode, sha) = tree_lookup_path(r.object_store.__getitem__, base_tree, path)
         return r[sha]
 
 
 def write_tree(repo):
     """Write a tree object from the index.
 
     Args:
       repo: Repository for which to write tree
     Returns: tree id for the tree that was written
     """
     with open_repo_closing(repo) as r:
         return r.open_index().commit(r.object_store)
diff --git a/dulwich/repo.py b/dulwich/repo.py
index 6cbdbf8f..0d34658f 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,1644 +1,1646 @@
 # repo.py -- For dealing with git repositories.
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 # Copyright (C) 2008-2013 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.
 #
 
 
 """Repository access.
 
 This module contains the base class for git repositories
 (BaseRepo) and an implementation which uses a repository on
 local disk (Repo).
 
 """
 
 from io import BytesIO
 import os
 import sys
 import stat
 import time
 from typing import Optional, Tuple, TYPE_CHECKING, List, Dict, Union, Iterable
 
 if TYPE_CHECKING:
     # There are no circular imports here, but we try to defer imports as long
     # as possible to reduce start-up time for anything that doesn't need
     # these imports.
     from dulwich.config import StackedConfig, ConfigFile
     from dulwich.index import Index
 
 from dulwich.errors import (
     NoIndexPresent,
     NotBlobError,
     NotCommitError,
     NotGitRepository,
     NotTreeError,
     NotTagError,
     CommitError,
     RefFormatError,
     HookError,
 )
 from dulwich.file import (
     GitFile,
 )
 from dulwich.object_store import (
     DiskObjectStore,
     MemoryObjectStore,
     BaseObjectStore,
     ObjectStoreGraphWalker,
 )
 from dulwich.objects import (
     check_hexsha,
     valid_hexsha,
     Blob,
     Commit,
     ShaFile,
     Tag,
     Tree,
 )
 from dulwich.pack import (
     pack_objects_to_data,
 )
 
 from dulwich.hooks import (
     Hook,
     PreCommitShellHook,
     PostCommitShellHook,
     CommitMsgShellHook,
     PostReceiveShellHook,
 )
 
 from dulwich.line_ending import BlobNormalizer, TreeBlobNormalizer
 
 from dulwich.refs import (  # noqa: F401
     ANNOTATED_TAG_SUFFIX,
     check_ref_format,
     RefsContainer,
     DictRefsContainer,
     InfoRefsContainer,
     DiskRefsContainer,
     read_packed_refs,
     read_packed_refs_with_peeled,
     write_packed_refs,
     SYMREF,
 )
 
 
 import warnings
 
 
 CONTROLDIR = ".git"
 OBJECTDIR = "objects"
 REFSDIR = "refs"
 REFSDIR_TAGS = "tags"
 REFSDIR_HEADS = "heads"
 INDEX_FILENAME = "index"
 COMMONDIR = "commondir"
 GITDIR = "gitdir"
 WORKTREES = "worktrees"
 
 BASE_DIRECTORIES = [
     ["branches"],
     [REFSDIR],
     [REFSDIR, REFSDIR_TAGS],
     [REFSDIR, REFSDIR_HEADS],
     ["hooks"],
     ["info"],
 ]
 
 DEFAULT_REF = b"refs/heads/master"
 
 
 class InvalidUserIdentity(Exception):
     """User identity is not of the format 'user <email>'"""
 
     def __init__(self, identity):
         self.identity = identity
 
 
 def _get_default_identity() -> Tuple[str, str]:
     import getpass
     import socket
 
     username = getpass.getuser()
     try:
         import pwd
     except ImportError:
         fullname = None
     else:
         try:
             gecos = pwd.getpwnam(username).pw_gecos
         except KeyError:
             fullname = None
         else:
             fullname = gecos.split(",")[0]
     if not fullname:
         fullname = username
     email = os.environ.get("EMAIL")
     if email is None:
         email = "{}@{}".format(username, socket.gethostname())
     return (fullname, email)
 
 
 def get_user_identity(config: "StackedConfig", kind: Optional[str] = None) -> bytes:
     """Determine the identity to use for new commits.
 
     If kind is set, this first checks
     GIT_${KIND}_NAME and GIT_${KIND}_EMAIL.
 
     If those variables are not set, then it will fall back
     to reading the user.name and user.email settings from
     the specified configuration.
 
     If that also fails, then it will fall back to using
     the current users' identity as obtained from the host
     system (e.g. the gecos field, $EMAIL, $USER@$(hostname -f).
 
     Args:
       kind: Optional kind to return identity for,
         usually either "AUTHOR" or "COMMITTER".
 
     Returns:
       A user identity
     """
     user = None  # type: Optional[bytes]
     email = None  # type: Optional[bytes]
     if kind:
         user_uc = os.environ.get("GIT_" + kind + "_NAME")
         if user_uc is not None:
             user = user_uc.encode("utf-8")
         email_uc = os.environ.get("GIT_" + kind + "_EMAIL")
         if email_uc is not None:
             email = email_uc.encode("utf-8")
     if user is None:
         try:
             user = config.get(("user",), "name")
         except KeyError:
             user = None
     if email is None:
         try:
             email = config.get(("user",), "email")
         except KeyError:
             email = None
     default_user, default_email = _get_default_identity()
     if user is None:
         user = default_user.encode("utf-8")
     if email is None:
         email = default_email.encode("utf-8")
     if email.startswith(b"<") and email.endswith(b">"):
         email = email[1:-1]
     return user + b" <" + email + b">"
 
 
 def check_user_identity(identity):
     """Verify that a user identity is formatted correctly.
 
     Args:
       identity: User identity bytestring
     Raises:
       InvalidUserIdentity: Raised when identity is invalid
     """
     try:
         fst, snd = identity.split(b" <", 1)
     except ValueError:
         raise InvalidUserIdentity(identity)
     if b">" not in snd:
         raise InvalidUserIdentity(identity)
 
 
 def parse_graftpoints(
     graftpoints: Iterable[bytes],
 ) -> Dict[bytes, List[bytes]]:
     """Convert a list of graftpoints into a dict
 
     Args:
       graftpoints: Iterator of graftpoint lines
 
     Each line is formatted as:
         <commit sha1> <parent sha1> [<parent sha1>]*
 
     Resulting dictionary is:
         <commit sha1>: [<parent sha1>*]
 
     https://git.wiki.kernel.org/index.php/GraftPoint
     """
     grafts = {}
     for line in graftpoints:
         raw_graft = line.split(None, 1)
 
         commit = raw_graft[0]
         if len(raw_graft) == 2:
             parents = raw_graft[1].split()
         else:
             parents = []
 
         for sha in [commit] + parents:
             check_hexsha(sha, "Invalid graftpoint")
 
         grafts[commit] = parents
     return grafts
 
 
 def serialize_graftpoints(graftpoints: Dict[bytes, List[bytes]]) -> bytes:
     """Convert a dictionary of grafts into string
 
     The graft dictionary is:
         <commit sha1>: [<parent sha1>*]
 
     Each line is formatted as:
         <commit sha1> <parent sha1> [<parent sha1>]*
 
     https://git.wiki.kernel.org/index.php/GraftPoint
 
     """
     graft_lines = []
     for commit, parents in graftpoints.items():
         if parents:
             graft_lines.append(commit + b" " + b" ".join(parents))
         else:
             graft_lines.append(commit)
     return b"\n".join(graft_lines)
 
 
 def _set_filesystem_hidden(path):
     """Mark path as to be hidden if supported by platform and filesystem.
 
     On win32 uses SetFileAttributesW api:
     <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>
     """
     if sys.platform == "win32":
         import ctypes
         from ctypes.wintypes import BOOL, DWORD, LPCWSTR
 
         FILE_ATTRIBUTE_HIDDEN = 2
         SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(
             ("SetFileAttributesW", ctypes.windll.kernel32)
         )
 
         if isinstance(path, bytes):
             path = os.fsdecode(path)
         if not SetFileAttributesW(path, FILE_ATTRIBUTE_HIDDEN):
             pass  # Could raise or log `ctypes.WinError()` here
 
     # Could implement other platform specific filesytem hiding here
 
 
 class ParentsProvider(object):
     def __init__(self, store, grafts={}, shallows=[]):
         self.store = store
         self.grafts = grafts
         self.shallows = set(shallows)
 
     def get_parents(self, commit_id, commit=None):
         try:
             return self.grafts[commit_id]
         except KeyError:
             pass
         if commit_id in self.shallows:
             return []
         if commit is None:
             commit = self.store[commit_id]
         return commit.parents
 
 
 class BaseRepo(object):
     """Base class for a git repository.
 
     :ivar object_store: Dictionary-like object for accessing
         the objects
     :ivar refs: Dictionary-like object with the refs in this
         repository
     """
 
     def __init__(self, object_store: BaseObjectStore, refs: RefsContainer):
         """Open a repository.
 
         This shouldn't be called directly, but rather through one of the
         base classes, such as MemoryRepo or Repo.
 
         Args:
           object_store: Object store to use
           refs: Refs container to use
         """
         self.object_store = object_store
         self.refs = refs
 
         self._graftpoints = {}  # type: Dict[bytes, List[bytes]]
         self.hooks = {}  # type: Dict[str, Hook]
 
     def _determine_file_mode(self) -> bool:
         """Probe the file-system to determine whether permissions can be trusted.
 
         Returns: True if permissions can be trusted, False otherwise.
         """
         raise NotImplementedError(self._determine_file_mode)
 
     def _init_files(self, bare: bool) -> None:
         """Initialize a default set of named files."""
         from dulwich.config import ConfigFile
 
         self._put_named_file("description", b"Unnamed repository")
         f = BytesIO()
         cf = ConfigFile()
         cf.set("core", "repositoryformatversion", "0")
         if self._determine_file_mode():
             cf.set("core", "filemode", True)
         else:
             cf.set("core", "filemode", False)
 
         cf.set("core", "bare", bare)
         cf.set("core", "logallrefupdates", True)
         cf.write_to_file(f)
         self._put_named_file("config", f.getvalue())
         self._put_named_file(os.path.join("info", "exclude"), b"")
 
     def get_named_file(self, path):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-based Repo, the object returned need not be
         pointing to a file in that location.
 
         Args:
           path: The path to the file, relative to the control dir.
         Returns: An open file object, or None if the file does not exist.
         """
         raise NotImplementedError(self.get_named_file)
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         Args:
           path: The path to the file, relative to the control dir.
           contents: A string to write to the file.
         """
         raise NotImplementedError(self._put_named_file)
 
     def _del_named_file(self, path):
         """Delete a file in the contrl directory with the given name."""
         raise NotImplementedError(self._del_named_file)
 
     def open_index(self):
         """Open the index for this repository.
 
         Raises:
           NoIndexPresent: If no index is present
         Returns: The matching `Index`
         """
         raise NotImplementedError(self.open_index)
 
     def fetch(self, target, determine_wants=None, progress=None, depth=None):
         """Fetch objects into another repository.
 
         Args:
           target: The target repository
           determine_wants: Optional function to determine what refs to
             fetch.
           progress: Optional progress function
           depth: Optional shallow fetch depth
         Returns: The local refs
         """
         if determine_wants is None:
             determine_wants = target.object_store.determine_wants_all
         count, pack_data = self.fetch_pack_data(
             determine_wants,
             target.get_graph_walker(),
             progress=progress,
             depth=depth,
         )
         target.object_store.add_pack_data(count, pack_data, progress)
         return self.get_refs()
 
     def fetch_pack_data(
         self,
         determine_wants,
         graph_walker,
         progress,
         get_tagged=None,
         depth=None,
     ):
         """Fetch the pack data required for a set of revisions.
 
         Args:
           determine_wants: Function that takes a dictionary with heads
             and returns the list of heads to fetch.
           graph_walker: Object that can iterate over the list of revisions
             to fetch and has an "ack" method that will be called to acknowledge
             that a revision is present.
           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.
           depth: Shallow fetch depth
         Returns: count and iterator over pack data
         """
         # TODO(jelmer): Fetch pack data directly, don't create objects first.
         objects = self.fetch_objects(
             determine_wants, graph_walker, progress, get_tagged, depth=depth
         )
         return pack_objects_to_data(objects)
 
     def fetch_objects(
         self,
         determine_wants,
         graph_walker,
         progress,
         get_tagged=None,
         depth=None,
     ):
         """Fetch the missing objects required for a set of revisions.
 
         Args:
           determine_wants: Function that takes a dictionary with heads
             and returns the list of heads to fetch.
           graph_walker: Object that can iterate over the list of revisions
             to fetch and has an "ack" method that will be called to acknowledge
             that a revision is present.
           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.
           depth: Shallow fetch depth
         Returns: iterator over objects, with __len__ implemented
         """
         if depth not in (None, 0):
             raise NotImplementedError("depth not supported yet")
 
         refs = {}
         for ref, sha in self.get_refs().items():
             try:
                 obj = self.object_store[sha]
             except KeyError:
                 warnings.warn(
                     "ref %s points at non-present sha %s"
                     % (ref.decode("utf-8", "replace"), sha.decode("ascii")),
                     UserWarning,
                 )
                 continue
             else:
                 if isinstance(obj, Tag):
                     refs[ref + ANNOTATED_TAG_SUFFIX] = obj.object[1]
                 refs[ref] = sha
 
         wants = determine_wants(refs)
         if not isinstance(wants, list):
             raise TypeError("determine_wants() did not return a list")
 
         shallows = getattr(graph_walker, "shallow", frozenset())
         unshallows = getattr(graph_walker, "unshallow", frozenset())
 
         if wants == []:
             # TODO(dborowitz): find a way to short-circuit that doesn't change
             # this interface.
 
             if shallows or unshallows:
                 # Do not send a pack in shallow short-circuit path
                 return None
 
             return []
 
         # If the graph walker is set up with an implementation that can
         # ACK/NAK to the wire, it will write data to the client through
         # this call as a side-effect.
         haves = self.object_store.find_common_revisions(graph_walker)
 
         # Deal with shallow requests separately because the haves do
         # not reflect what objects are missing
         if shallows or unshallows:
             # TODO: filter the haves commits from iter_shas. the specific
             # commits aren't missing.
             haves = []
 
         parents_provider = ParentsProvider(self.object_store, shallows=shallows)
 
         def get_parents(commit):
             return parents_provider.get_parents(commit.id, commit)
 
         return self.object_store.iter_shas(
             self.object_store.find_missing_objects(
                 haves,
                 wants,
                 self.get_shallow(),
                 progress,
                 get_tagged,
                 get_parents=get_parents,
             )
         )
 
     def generate_pack_data(self, have, want, progress=None, ofs_delta=None):
         """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
           ofs_delta: Whether OFS deltas can be included
           progress: Optional progress reporting method
         """
         return self.object_store.generate_pack_data(
             have,
             want,
             shallow=self.get_shallow(),
             progress=progress,
             ofs_delta=ofs_delta,
         )
 
     def get_graph_walker(self, heads=None):
         """Retrieve a graph walker.
 
         A graph walker is used by a remote repository (or proxy)
         to find out which objects are present in this repository.
 
         Args:
           heads: Repository heads to use (optional)
         Returns: A graph walker object
         """
         if heads is None:
             heads = [
                 sha
                 for sha in self.refs.as_dict(b"refs/heads").values()
                 if sha in self.object_store
             ]
         parents_provider = ParentsProvider(self.object_store)
         return ObjectStoreGraphWalker(
             heads, parents_provider.get_parents, shallow=self.get_shallow()
         )
 
     def get_refs(self) -> Dict[bytes, bytes]:
         """Get dictionary with all refs.
 
         Returns: A ``dict`` mapping ref names to SHA1s
         """
         return self.refs.as_dict()
 
     def head(self) -> bytes:
         """Return the SHA1 pointed at by HEAD."""
         return self.refs[b"HEAD"]
 
     def _get_object(self, sha, cls):
         assert len(sha) in (20, 40)
         ret = self.get_object(sha)
         if not isinstance(ret, cls):
             if cls is Commit:
                 raise NotCommitError(ret)
             elif cls is Blob:
                 raise NotBlobError(ret)
             elif cls is Tree:
                 raise NotTreeError(ret)
             elif cls is Tag:
                 raise NotTagError(ret)
             else:
                 raise Exception(
                     "Type invalid: %r != %r" % (ret.type_name, cls.type_name)
                 )
         return ret
 
     def get_object(self, sha: bytes) -> ShaFile:
         """Retrieve the object with the specified SHA.
 
         Args:
           sha: SHA to retrieve
         Returns: A ShaFile object
         Raises:
           KeyError: when the object can not be found
         """
         return self.object_store[sha]
 
     def parents_provider(self):
         return ParentsProvider(
             self.object_store,
             grafts=self._graftpoints,
             shallows=self.get_shallow(),
         )
 
     def get_parents(self, sha: bytes, commit: Commit = None) -> List[bytes]:
         """Retrieve the parents of a specific commit.
 
         If the specific commit is a graftpoint, the graft parents
         will be returned instead.
 
         Args:
           sha: SHA of the commit for which to retrieve the parents
           commit: Optional commit matching the sha
         Returns: List of parents
         """
         return self.parents_provider().get_parents(sha, commit)
 
     def get_config(self):
         """Retrieve the config object.
 
         Returns: `ConfigFile` object for the ``.git/config`` file.
         """
         raise NotImplementedError(self.get_config)
 
     def get_description(self):
         """Retrieve the description for this repository.
 
         Returns: String with the description of the repository
             as set by the user.
         """
         raise NotImplementedError(self.get_description)
 
     def set_description(self, description):
         """Set the description for this repository.
 
         Args:
           description: Text to set as description for this repository.
         """
         raise NotImplementedError(self.set_description)
 
     def get_config_stack(self) -> "StackedConfig":
         """Return a config stack for this repository.
 
         This stack accesses the configuration for both this repository
         itself (.git/config) and the global configuration, which usually
         lives in ~/.gitconfig.
 
         Returns: `Config` instance for this repository
         """
         from dulwich.config import StackedConfig
 
         backends = [self.get_config()] + StackedConfig.default_backends()
         return StackedConfig(backends, writable=backends[0])
 
     def get_shallow(self):
         """Get the set of shallow commits.
 
         Returns: Set of shallow commits.
         """
         f = self.get_named_file("shallow")
         if f is None:
             return set()
         with f:
             return {line.strip() for line in f}
 
     def update_shallow(self, new_shallow, new_unshallow):
         """Update the list of shallow objects.
 
         Args:
           new_shallow: Newly shallow objects
           new_unshallow: Newly no longer shallow objects
         """
         shallow = self.get_shallow()
         if new_shallow:
             shallow.update(new_shallow)
         if new_unshallow:
             shallow.difference_update(new_unshallow)
         if shallow:
             self._put_named_file(
                 "shallow", b"".join([sha + b"\n" for sha in shallow])
             )
         else:
             self._del_named_file("shallow")
 
     def get_peeled(self, ref):
         """Get the peeled value of a ref.
 
         Args:
           ref: The refname 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.
         """
         cached = self.refs.get_peeled(ref)
         if cached is not None:
             return cached
         return self.object_store.peel_sha(self.refs[ref]).id
 
     def get_walker(self, include=None, *args, **kwargs):
         """Obtain a walker for this repository.
 
         Args:
           include: Iterable of SHAs of commits to include along with their
             ancestors. Defaults to [HEAD]
           exclude: Iterable of SHAs of commits to exclude along with their
             ancestors, overriding includes.
           order: ORDER_* constant specifying the order of results.
             Anything other than ORDER_DATE may result in O(n) memory usage.
           reverse: If True, reverse the order of output, requiring O(n)
             memory.
           max_entries: The maximum number of entries to yield, or None for
             no limit.
           paths: Iterable of file or subtree paths to show entries for.
           rename_detector: diff.RenameDetector object for detecting
             renames.
           follow: If True, follow path across renames/copies. Forces a
             default rename_detector.
           since: Timestamp to list commits after.
           until: Timestamp to list commits before.
           queue_cls: A class to use for a queue of commits, supporting the
             iterator protocol. The constructor takes a single argument, the
             Walker.
         Returns: A `Walker` object
         """
         from dulwich.walk import Walker
 
         if include is None:
             include = [self.head()]
         if isinstance(include, str):
             include = [include]
 
         kwargs["get_parents"] = lambda commit: self.get_parents(commit.id, commit)
 
         return Walker(self.object_store, include, *args, **kwargs)
 
     def __getitem__(self, name):
         """Retrieve a Git object by SHA1 or ref.
 
         Args:
           name: A Git object SHA1 or a ref name
         Returns: A `ShaFile` object, such as a Commit or Blob
         Raises:
           KeyError: when the specified ref or object does not exist
         """
         if not isinstance(name, bytes):
             raise TypeError(
                 "'name' must be bytestring, not %.80s" % type(name).__name__
             )
         if len(name) in (20, 40):
             try:
                 return self.object_store[name]
             except (KeyError, ValueError):
                 pass
         try:
             return self.object_store[self.refs[name]]
         except RefFormatError:
             raise KeyError(name)
 
     def __contains__(self, name: bytes) -> bool:
         """Check if a specific Git object or ref is present.
 
         Args:
           name: Git object SHA1 or ref name
         """
         if len(name) == 20 or (len(name) == 40 and valid_hexsha(name)):
             return name in self.object_store or name in self.refs
         else:
             return name in self.refs
 
     def __setitem__(self, name: bytes, value: Union[ShaFile, bytes]):
         """Set a ref.
 
         Args:
           name: ref name
           value: Ref value - either a ShaFile object, or a hex sha
         """
         if name.startswith(b"refs/") or name == b"HEAD":
             if isinstance(value, ShaFile):
                 self.refs[name] = value.id
             elif isinstance(value, bytes):
                 self.refs[name] = value
             else:
                 raise TypeError(value)
         else:
             raise ValueError(name)
 
     def __delitem__(self, name: bytes):
         """Remove a ref.
 
         Args:
           name: Name of the ref to remove
         """
         if name.startswith(b"refs/") or name == b"HEAD":
             del self.refs[name]
         else:
             raise ValueError(name)
 
     def _get_user_identity(self, config: "StackedConfig", kind: str = None) -> bytes:
         """Determine the identity to use for new commits."""
         # TODO(jelmer): Deprecate this function in favor of get_user_identity
         return get_user_identity(config)
 
     def _add_graftpoints(self, updated_graftpoints: Dict[bytes, List[bytes]]):
         """Add or modify graftpoints
 
         Args:
           updated_graftpoints: Dict of commit shas to list of parent shas
         """
 
         # Simple validation
         for commit, parents in updated_graftpoints.items():
             for sha in [commit] + parents:
                 check_hexsha(sha, "Invalid graftpoint")
 
         self._graftpoints.update(updated_graftpoints)
 
     def _remove_graftpoints(self, to_remove: List[bytes] = []) -> None:
         """Remove graftpoints
 
         Args:
           to_remove: List of commit shas
         """
         for sha in to_remove:
             del self._graftpoints[sha]
 
     def _read_heads(self, name):
         f = self.get_named_file(name)
         if f is None:
             return []
         with f:
             return [line.strip() for line in f.readlines() if line.strip()]
 
     def do_commit(  # noqa: C901
         self,
         message=None,
         committer=None,
         author=None,
         commit_timestamp=None,
         commit_timezone=None,
         author_timestamp=None,
         author_timezone=None,
         tree=None,
         encoding=None,
         ref=b"HEAD",
         merge_heads=None,
         no_verify=False,
     ):
         """Create a new commit.
 
         If not specified, `committer` and `author` default to
         get_user_identity(..., 'COMMITTER')
         and get_user_identity(..., 'AUTHOR') respectively.
 
         Args:
           message: Commit message
           committer: Committer fullname
           author: Author fullname
           commit_timestamp: Commit timestamp (defaults to now)
           commit_timezone: Commit timestamp timezone (defaults to GMT)
           author_timestamp: Author timestamp (defaults to commit
             timestamp)
           author_timezone: Author timestamp timezone
             (defaults to commit timestamp timezone)
           tree: SHA1 of the tree root to use (if not specified the
             current index will be committed).
           encoding: Encoding
           ref: Optional ref to commit to (defaults to current branch)
           merge_heads: Merge heads (defaults to .git/MERGE_HEAD)
           no_verify: Skip pre-commit and commit-msg hooks
 
         Returns:
           New commit SHA1
         """
 
         c = Commit()
         if tree is None:
             index = self.open_index()
             c.tree = index.commit(self.object_store)
         else:
             if len(tree) != 40:
                 raise ValueError("tree must be a 40-byte hex sha string")
             c.tree = tree
 
         try:
             if not no_verify:
                 self.hooks["pre-commit"].execute()
         except HookError as e:
             raise CommitError(e)
         except KeyError:  # no hook defined, silent fallthrough
             pass
 
         config = self.get_config_stack()
         if merge_heads is None:
             merge_heads = self._read_heads("MERGE_HEAD")
         if committer is None:
             committer = get_user_identity(config, kind="COMMITTER")
         check_user_identity(committer)
         c.committer = committer
         if commit_timestamp is None:
             # FIXME: Support GIT_COMMITTER_DATE environment variable
             commit_timestamp = time.time()
         c.commit_time = int(commit_timestamp)
         if commit_timezone is None:
             # FIXME: Use current user timezone rather than UTC
             commit_timezone = 0
         c.commit_timezone = commit_timezone
         if author is None:
             author = get_user_identity(config, kind="AUTHOR")
         c.author = author
         check_user_identity(author)
         if author_timestamp is None:
             # FIXME: Support GIT_AUTHOR_DATE environment variable
             author_timestamp = commit_timestamp
         c.author_time = int(author_timestamp)
         if author_timezone is None:
             author_timezone = commit_timezone
         c.author_timezone = author_timezone
         if encoding is None:
             try:
                 encoding = config.get(("i18n",), "commitEncoding")
             except KeyError:
                 pass  # No dice
         if encoding is not None:
             c.encoding = encoding
         if message is None:
             # FIXME: Try to read commit message from .git/MERGE_MSG
             raise ValueError("No commit message specified")
 
         try:
             if no_verify:
                 c.message = message
             else:
                 c.message = self.hooks["commit-msg"].execute(message)
                 if c.message is None:
                     c.message = message
         except HookError as e:
             raise CommitError(e)
         except KeyError:  # no hook defined, message not modified
             c.message = message
 
         if ref is None:
             # Create a dangling commit
             c.parents = merge_heads
             self.object_store.add_object(c)
         else:
             try:
                 old_head = self.refs[ref]
                 c.parents = [old_head] + merge_heads
                 self.object_store.add_object(c)
                 ok = self.refs.set_if_equals(
                     ref,
                     old_head,
                     c.id,
                     message=b"commit: " + message,
                     committer=committer,
                     timestamp=commit_timestamp,
                     timezone=commit_timezone,
                 )
             except KeyError:
                 c.parents = merge_heads
                 self.object_store.add_object(c)
                 ok = self.refs.add_if_new(
                     ref,
                     c.id,
                     message=b"commit: " + message,
                     committer=committer,
                     timestamp=commit_timestamp,
                     timezone=commit_timezone,
                 )
             if not ok:
                 # Fail if the atomic compare-and-swap failed, leaving the
                 # commit and all its objects as garbage.
                 raise CommitError("%s changed during commit" % (ref,))
 
         self._del_named_file("MERGE_HEAD")
 
         try:
             self.hooks["post-commit"].execute()
         except HookError as e:  # silent failure
             warnings.warn("post-commit hook failed: %s" % e, UserWarning)
         except KeyError:  # no hook defined, silent fallthrough
             pass
 
         return c.id
 
 
 def read_gitfile(f):
     """Read a ``.git`` file.
 
     The first line of the file should start with "gitdir: "
 
     Args:
       f: File-like object to read from
     Returns: A path
     """
     cs = f.read()
     if not cs.startswith("gitdir: "):
         raise ValueError("Expected file to start with 'gitdir: '")
     return cs[len("gitdir: ") :].rstrip("\n")
 
 
 class UnsupportedVersion(Exception):
     """Unsupported repository version."""
 
     def __init__(self, version):
         self.version = version
 
 
 class Repo(BaseRepo):
     """A git repository backed by local disk.
 
     To open an existing repository, call the contructor with
     the path of the repository.
 
     To create a new repository, use the Repo.init class method.
     """
 
     def __init__(self, root, object_store=None, bare=None):
         hidden_path = os.path.join(root, CONTROLDIR)
         if bare is None:
             if (os.path.isfile(hidden_path) or
                     os.path.isdir(os.path.join(hidden_path, OBJECTDIR))):
                 bare = False
             elif (os.path.isdir(os.path.join(root, OBJECTDIR)) and
                     os.path.isdir(os.path.join(root, REFSDIR))):
                 bare = True
             else:
                 raise NotGitRepository(
                     "No git repository was found at %(path)s" % dict(path=root)
                 )
 
         self.bare = bare
         if bare is False:
             if os.path.isfile(hidden_path):
                 with open(hidden_path, "r") as f:
                     path = read_gitfile(f)
                 self.bare = False
                 self._controldir = os.path.join(root, path)
             else:
                 self._controldir = hidden_path
         else:
             self._controldir = root
         commondir = self.get_named_file(COMMONDIR)
         if commondir is not None:
             with commondir:
                 self._commondir = os.path.join(
                     self.controldir(),
                     os.fsdecode(commondir.read().rstrip(b"\r\n")),
                 )
         else:
             self._commondir = self._controldir
         self.path = root
         config = self.get_config()
         try:
             format_version = int(config.get("core", "repositoryformatversion"))
         except KeyError:
             format_version = 0
         if format_version != 0:
             raise UnsupportedVersion(format_version)
         if object_store is None:
             object_store = DiskObjectStore.from_config(
                 os.path.join(self.commondir(), OBJECTDIR), config
             )
         refs = DiskRefsContainer(
             self.commondir(), self._controldir, logger=self._write_reflog
         )
         BaseRepo.__init__(self, object_store, refs)
 
         self._graftpoints = {}
         graft_file = self.get_named_file(
             os.path.join("info", "grafts"), basedir=self.commondir()
         )
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
         graft_file = self.get_named_file("shallow", basedir=self.commondir())
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
 
         self.hooks["pre-commit"] = PreCommitShellHook(self.controldir())
         self.hooks["commit-msg"] = CommitMsgShellHook(self.controldir())
         self.hooks["post-commit"] = PostCommitShellHook(self.controldir())
         self.hooks["post-receive"] = PostReceiveShellHook(self.controldir())
 
     def _write_reflog(
         self, ref, old_sha, new_sha, committer, timestamp, timezone, message
     ):
         from .reflog import format_reflog_line
 
         path = os.path.join(self.controldir(), "logs", os.fsdecode(ref))
         try:
             os.makedirs(os.path.dirname(path))
         except FileExistsError:
             pass
         if committer is None:
             config = self.get_config_stack()
             committer = self._get_user_identity(config)
         check_user_identity(committer)
         if timestamp is None:
             timestamp = int(time.time())
         if timezone is None:
             timezone = 0  # FIXME
         with open(path, "ab") as f:
             f.write(
                 format_reflog_line(
                     old_sha, new_sha, committer, timestamp, timezone, message
                 )
                 + b"\n"
             )
 
     @classmethod
     def discover(cls, start="."):
         """Iterate parent directories to discover a repository
 
         Return a Repo object for the first parent directory that looks like a
         Git repository.
 
         Args:
           start: The directory to start discovery from (defaults to '.')
         """
         remaining = True
         path = os.path.abspath(start)
         while remaining:
             try:
                 return cls(path)
             except NotGitRepository:
                 path, remaining = os.path.split(path)
         raise NotGitRepository(
             "No git repository was found at %(path)s" % dict(path=start)
         )
 
     def controldir(self):
         """Return the path of the control directory."""
         return self._controldir
 
     def commondir(self):
         """Return the path of the common directory.
 
         For a main working tree, it is identical to controldir().
 
         For a linked working tree, it is the control directory of the
         main working tree."""
 
         return self._commondir
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         Returns: True if permissions can be trusted, False otherwise.
         """
         fname = os.path.join(self.path, ".probe-permissions")
         with open(fname, "w") as f:
             f.write("")
 
         st1 = os.lstat(fname)
         try:
             os.chmod(fname, st1.st_mode ^ stat.S_IXUSR)
         except PermissionError:
             return False
         st2 = os.lstat(fname)
 
         os.unlink(fname)
 
         mode_differs = st1.st_mode != st2.st_mode
         st2_has_exec = (st2.st_mode & stat.S_IXUSR) != 0
 
         return mode_differs and st2_has_exec
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         Args:
           path: The path to the file, relative to the control dir.
           contents: A string to write to the file.
         """
         path = path.lstrip(os.path.sep)
         with GitFile(os.path.join(self.controldir(), path), "wb") as f:
             f.write(contents)
 
     def _del_named_file(self, path):
         try:
             os.unlink(os.path.join(self.controldir(), path))
         except FileNotFoundError:
             return
 
     def get_named_file(self, path, basedir=None):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-based Repo, the object returned need not be
         pointing to a file in that location.
 
         Args:
           path: The path to the file, relative to the control dir.
           basedir: Optional argument that specifies an alternative to the
             control dir.
         Returns: An open file object, or None if the file does not exist.
         """
         # TODO(dborowitz): sanitize filenames, since this is used directly by
         # the dumb web serving code.
         if basedir is None:
             basedir = self.controldir()
         path = path.lstrip(os.path.sep)
         try:
             return open(os.path.join(basedir, path), "rb")
         except FileNotFoundError:
             return None
 
     def index_path(self):
         """Return path to the index file."""
         return os.path.join(self.controldir(), INDEX_FILENAME)
 
     def open_index(self) -> "Index":
         """Open the index for this repository.
 
         Raises:
           NoIndexPresent: If no index is present
         Returns: The matching `Index`
         """
         from dulwich.index import Index
 
         if not self.has_index():
             raise NoIndexPresent()
         return Index(self.index_path())
 
     def has_index(self):
         """Check if an index is present."""
         # Bare repos must never have index files; non-bare repos may have a
         # missing index file, which is treated as empty.
         return not self.bare
 
     def stage(self, fs_paths):
         """Stage a set of paths.
 
         Args:
           fs_paths: List of paths, relative to the repository path
         """
 
         root_path_bytes = os.fsencode(self.path)
 
-        if not isinstance(fs_paths, list):
+        if isinstance(fs_paths, str):
             fs_paths = [fs_paths]
+        fs_paths = list(fs_paths)
+
         from dulwich.index import (
             blob_from_path_and_stat,
             index_entry_from_stat,
             _fs_to_tree_path,
         )
 
         index = self.open_index()
         blob_normalizer = self.get_blob_normalizer()
         for fs_path in fs_paths:
             if not isinstance(fs_path, bytes):
                 fs_path = os.fsencode(fs_path)
             if os.path.isabs(fs_path):
                 raise ValueError(
                     "path %r should be relative to "
                     "repository root, not absolute" % fs_path
                 )
             tree_path = _fs_to_tree_path(fs_path)
             full_path = os.path.join(root_path_bytes, fs_path)
             try:
                 st = os.lstat(full_path)
             except OSError:
                 # File no longer exists
                 try:
                     del index[tree_path]
                 except KeyError:
                     pass  # already removed
             else:
                 if not stat.S_ISREG(st.st_mode) and not stat.S_ISLNK(st.st_mode):
                     try:
                         del index[tree_path]
                     except KeyError:
                         pass
                 else:
                     blob = blob_from_path_and_stat(full_path, st)
                     blob = blob_normalizer.checkin_normalize(blob, fs_path)
                     self.object_store.add_object(blob)
                     index[tree_path] = index_entry_from_stat(st, blob.id, 0)
         index.write()
 
     def clone(
         self,
         target_path,
         mkdir=True,
         bare=False,
         origin=b"origin",
         checkout=None,
     ):
         """Clone this repository.
 
         Args:
           target_path: Target path
           mkdir: Create the target directory
           bare: Whether to create a bare repository
           origin: Base name for refs in target repository
             cloned from this repository
         Returns: Created repository as `Repo`
         """
         if not bare:
             target = self.init(target_path, mkdir=mkdir)
         else:
             if checkout:
                 raise ValueError("checkout and bare are incompatible")
             target = self.init_bare(target_path, mkdir=mkdir)
         self.fetch(target)
         encoded_path = self.path
         if not isinstance(encoded_path, bytes):
             encoded_path = os.fsencode(encoded_path)
         ref_message = b"clone: from " + encoded_path
         target.refs.import_refs(
             b"refs/remotes/" + origin,
             self.refs.as_dict(b"refs/heads"),
             message=ref_message,
         )
         target.refs.import_refs(
             b"refs/tags", self.refs.as_dict(b"refs/tags"), message=ref_message
         )
         try:
             target.refs.add_if_new(
                 DEFAULT_REF, self.refs[DEFAULT_REF], message=ref_message
             )
         except KeyError:
             pass
         target_config = target.get_config()
         target_config.set(("remote", "origin"), "url", encoded_path)
         target_config.set(
             ("remote", "origin"),
             "fetch",
             "+refs/heads/*:refs/remotes/origin/*",
         )
         target_config.write_to_path()
 
         # Update target head
         head_chain, head_sha = self.refs.follow(b"HEAD")
         if head_chain and head_sha is not None:
             target.refs.set_symbolic_ref(b"HEAD", head_chain[-1], message=ref_message)
             target[b"HEAD"] = head_sha
 
             if checkout is None:
                 checkout = not bare
             if checkout:
                 # Checkout HEAD to target dir
                 target.reset_index()
 
         return target
 
     def reset_index(self, tree=None):
         """Reset the index back to a specific tree.
 
         Args:
           tree: Tree SHA to reset to, None for current HEAD tree.
         """
         from dulwich.index import (
             build_index_from_tree,
             validate_path_element_default,
             validate_path_element_ntfs,
         )
 
         if tree is None:
             tree = self[b"HEAD"].tree
         config = self.get_config()
         honor_filemode = config.get_boolean(b"core", b"filemode", os.name != "nt")
         if config.get_boolean(b"core", b"core.protectNTFS", os.name == "nt"):
             validate_path_element = validate_path_element_ntfs
         else:
             validate_path_element = validate_path_element_default
         return build_index_from_tree(
             self.path,
             self.index_path(),
             self.object_store,
             tree,
             honor_filemode=honor_filemode,
             validate_path_element=validate_path_element,
         )
 
     def get_config(self) -> "ConfigFile":
         """Retrieve the config object.
 
         Returns: `ConfigFile` object for the ``.git/config`` file.
         """
         from dulwich.config import ConfigFile
 
         path = os.path.join(self._controldir, "config")
         try:
             return ConfigFile.from_path(path)
         except FileNotFoundError:
             ret = ConfigFile()
             ret.path = path
             return ret
 
     def get_description(self):
         """Retrieve the description of this repository.
 
         Returns: A string describing the repository or None.
         """
         path = os.path.join(self._controldir, "description")
         try:
             with GitFile(path, "rb") as f:
                 return f.read()
         except FileNotFoundError:
             return None
 
     def __repr__(self):
         return "<Repo at %r>" % self.path
 
     def set_description(self, description):
         """Set the description for this repository.
 
         Args:
           description: Text to set as description for this repository.
         """
 
         self._put_named_file("description", description)
 
     @classmethod
     def _init_maybe_bare(cls, path, controldir, bare, object_store=None):
         for d in BASE_DIRECTORIES:
             os.mkdir(os.path.join(controldir, *d))
         if object_store is None:
             object_store = DiskObjectStore.init(os.path.join(controldir, OBJECTDIR))
         ret = cls(path, bare=bare, object_store=object_store)
         ret.refs.set_symbolic_ref(b"HEAD", DEFAULT_REF)
         ret._init_files(bare)
         return ret
 
     @classmethod
     def init(cls, path, mkdir=False):
         """Create a new repository.
 
         Args:
           path: Path in which to create the repository
           mkdir: Whether to create the directory
         Returns: `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         controldir = os.path.join(path, CONTROLDIR)
         os.mkdir(controldir)
         _set_filesystem_hidden(controldir)
         return cls._init_maybe_bare(path, controldir, False)
 
     @classmethod
     def _init_new_working_directory(cls, path, main_repo, identifier=None, mkdir=False):
         """Create a new working directory linked to a repository.
 
         Args:
           path: Path in which to create the working tree.
           main_repo: Main repository to reference
           identifier: Worktree identifier
           mkdir: Whether to create the directory
         Returns: `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         if identifier is None:
             identifier = os.path.basename(path)
         main_worktreesdir = os.path.join(main_repo.controldir(), WORKTREES)
         worktree_controldir = os.path.join(main_worktreesdir, identifier)
         gitdirfile = os.path.join(path, CONTROLDIR)
         with open(gitdirfile, "wb") as f:
             f.write(b"gitdir: " + os.fsencode(worktree_controldir) + b"\n")
         try:
             os.mkdir(main_worktreesdir)
         except FileExistsError:
             pass
         try:
             os.mkdir(worktree_controldir)
         except FileExistsError:
             pass
         with open(os.path.join(worktree_controldir, GITDIR), "wb") as f:
             f.write(os.fsencode(gitdirfile) + b"\n")
         with open(os.path.join(worktree_controldir, COMMONDIR), "wb") as f:
             f.write(b"../..\n")
         with open(os.path.join(worktree_controldir, "HEAD"), "wb") as f:
             f.write(main_repo.head() + b"\n")
         r = cls(path)
         r.reset_index()
         return r
 
     @classmethod
     def init_bare(cls, path, mkdir=False, object_store=None):
         """Create a new bare repository.
 
         ``path`` should already exist and be an empty directory.
 
         Args:
           path: Path to create bare repository in
         Returns: a `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         return cls._init_maybe_bare(path, path, True, object_store=object_store)
 
     create = init_bare
 
     def close(self):
         """Close any files opened by this repository."""
         self.object_store.close()
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
     def get_blob_normalizer(self):
         """Return a BlobNormalizer object"""
         # TODO Parse the git attributes files
         git_attributes = {}
         config_stack = self.get_config_stack()
         try:
             tree = self.object_store[self.refs[b"HEAD"]].tree
             return TreeBlobNormalizer(
                 config_stack,
                 git_attributes,
                 self.object_store,
                 tree,
             )
         except KeyError:
             return BlobNormalizer(config_stack, git_attributes)
 
 
 class MemoryRepo(BaseRepo):
     """Repo that stores refs, objects, and named files in memory.
 
     MemoryRepos are always bare: they have no working tree and no index, since
     those have a stronger dependency on the filesystem.
     """
 
     def __init__(self):
         from dulwich.config import ConfigFile
 
         self._reflog = []
         refs_container = DictRefsContainer({}, logger=self._append_reflog)
         BaseRepo.__init__(self, MemoryObjectStore(), refs_container)
         self._named_files = {}
         self.bare = True
         self._config = ConfigFile()
         self._description = None
 
     def _append_reflog(self, *args):
         self._reflog.append(args)
 
     def set_description(self, description):
         self._description = description
 
     def get_description(self):
         return self._description
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         Returns: True if permissions can be trusted, False otherwise.
         """
         return sys.platform != "win32"
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         Args:
           path: The path to the file, relative to the control dir.
           contents: A string to write to the file.
         """
         self._named_files[path] = contents
 
     def _del_named_file(self, path):
         try:
             del self._named_files[path]
         except KeyError:
             pass
 
     def get_named_file(self, path, basedir=None):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-baked Repo, the object returned need not be
         pointing to a file in that location.
 
         Args:
           path: The path to the file, relative to the control dir.
         Returns: An open file object, or None if the file does not exist.
         """
         contents = self._named_files.get(path, None)
         if contents is None:
             return None
         return BytesIO(contents)
 
     def open_index(self):
         """Fail to open index for this repo, since it is bare.
 
         Raises:
           NoIndexPresent: Raised when no index is present
         """
         raise NoIndexPresent()
 
     def get_config(self):
         """Retrieve the config object.
 
         Returns: `ConfigFile` object.
         """
         return self._config
 
     @classmethod
     def init_bare(cls, objects, refs):
         """Create a new bare repository in memory.
 
         Args:
           objects: Objects for the new repository,
             as iterable
           refs: Refs as dictionary, mapping names
             to object SHA1s
         """
         ret = cls()
         for obj in objects:
             ret.object_store.add_object(obj)
         for refname, sha in refs.items():
             ret.refs.add_if_new(refname, sha)
         ret._init_files(bare=True)
         return ret
diff --git a/dulwich/tests/test_config.py b/dulwich/tests/test_config.py
index 72f9e5c2..487c2aa8 100644
--- a/dulwich/tests/test_config.py
+++ b/dulwich/tests/test_config.py
@@ -1,414 +1,419 @@
 # test_config.py -- Tests for reading and writing configuration files
 # Copyright (C) 2011 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 reading and writing configuration files."""
 
 import os
 import sys
 from io import BytesIO
 from unittest import skipIf
 from unittest.mock import patch
 
 from dulwich.config import (
     ConfigDict,
     ConfigFile,
     StackedConfig,
     _check_section_name,
     _check_variable_name,
     _format_string,
     _escape_value,
     _parse_string,
     parse_submodules,
 )
 from dulwich.tests import (
     TestCase,
 )
 
 
 class ConfigFileTests(TestCase):
     def from_file(self, text):
         return ConfigFile.from_file(BytesIO(text))
 
     def test_empty(self):
         ConfigFile()
 
     def test_eq(self):
         self.assertEqual(ConfigFile(), ConfigFile())
 
     def test_default_config(self):
         cf = self.from_file(
             b"""[core]
 \trepositoryformatversion = 0
 \tfilemode = true
 \tbare = false
 \tlogallrefupdates = true
 """
         )
         self.assertEqual(
             ConfigFile(
                 {
                     (b"core",): {
                         b"repositoryformatversion": b"0",
                         b"filemode": b"true",
                         b"bare": b"false",
                         b"logallrefupdates": b"true",
                     }
                 }
             ),
             cf,
         )
 
     def test_from_file_empty(self):
         cf = self.from_file(b"")
         self.assertEqual(ConfigFile(), cf)
 
     def test_empty_line_before_section(self):
         cf = self.from_file(b"\n[section]\n")
         self.assertEqual(ConfigFile({(b"section",): {}}), cf)
 
     def test_comment_before_section(self):
         cf = self.from_file(b"# foo\n[section]\n")
         self.assertEqual(ConfigFile({(b"section",): {}}), cf)
 
     def test_comment_after_section(self):
         cf = self.from_file(b"[section] # foo\n")
         self.assertEqual(ConfigFile({(b"section",): {}}), cf)
 
     def test_comment_after_variable(self):
         cf = self.from_file(b"[section]\nbar= foo # a comment\n")
         self.assertEqual(ConfigFile({(b"section",): {b"bar": b"foo"}}), cf)
 
     def test_comment_character_within_value_string(self):
         cf = self.from_file(b'[section]\nbar= "foo#bar"\n')
         self.assertEqual(ConfigFile({(b"section",): {b"bar": b"foo#bar"}}), cf)
 
     def test_comment_character_within_section_string(self):
         cf = self.from_file(b'[branch "foo#bar"] # a comment\nbar= foo\n')
         self.assertEqual(ConfigFile({(b"branch", b"foo#bar"): {b"bar": b"foo"}}), cf)
 
     def test_from_file_section(self):
         cf = self.from_file(b"[core]\nfoo = bar\n")
         self.assertEqual(b"bar", cf.get((b"core",), b"foo"))
         self.assertEqual(b"bar", cf.get((b"core", b"foo"), b"foo"))
 
+    def test_from_file_utf8_bom(self):
+        text = "[core]\nfoo = b\u00e4r\n".encode("utf-8-sig")
+        cf = self.from_file(text)
+        self.assertEqual(b"b\xc3\xa4r", cf.get((b"core",), b"foo"))
+
     def test_from_file_section_case_insensitive_lower(self):
         cf = self.from_file(b"[cOre]\nfOo = bar\n")
         self.assertEqual(b"bar", cf.get((b"core",), b"foo"))
         self.assertEqual(b"bar", cf.get((b"core", b"foo"), b"foo"))
 
     def test_from_file_section_case_insensitive_mixed(self):
         cf = self.from_file(b"[cOre]\nfOo = bar\n")
         self.assertEqual(b"bar", cf.get((b"core",), b"fOo"))
         self.assertEqual(b"bar", cf.get((b"cOre", b"fOo"), b"fOo"))
 
     def test_from_file_with_mixed_quoted(self):
         cf = self.from_file(b'[core]\nfoo = "bar"la\n')
         self.assertEqual(b"barla", cf.get((b"core",), b"foo"))
 
     def test_from_file_section_with_open_brackets(self):
         self.assertRaises(ValueError, self.from_file, b"[core\nfoo = bar\n")
 
     def test_from_file_value_with_open_quoted(self):
         self.assertRaises(ValueError, self.from_file, b'[core]\nfoo = "bar\n')
 
     def test_from_file_with_quotes(self):
         cf = self.from_file(b"[core]\n" b'foo = " bar"\n')
         self.assertEqual(b" bar", cf.get((b"core",), b"foo"))
 
     def test_from_file_with_interrupted_line(self):
         cf = self.from_file(b"[core]\n" b"foo = bar\\\n" b" la\n")
         self.assertEqual(b"barla", cf.get((b"core",), b"foo"))
 
     def test_from_file_with_boolean_setting(self):
         cf = self.from_file(b"[core]\n" b"foo\n")
         self.assertEqual(b"true", cf.get((b"core",), b"foo"))
 
     def test_from_file_subsection(self):
         cf = self.from_file(b'[branch "foo"]\nfoo = bar\n')
         self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
 
     def test_from_file_subsection_invalid(self):
         self.assertRaises(ValueError, self.from_file, b'[branch "foo]\nfoo = bar\n')
 
     def test_from_file_subsection_not_quoted(self):
         cf = self.from_file(b"[branch.foo]\nfoo = bar\n")
         self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
 
     def test_write_to_file_empty(self):
         c = ConfigFile()
         f = BytesIO()
         c.write_to_file(f)
         self.assertEqual(b"", f.getvalue())
 
     def test_write_to_file_section(self):
         c = ConfigFile()
         c.set((b"core",), b"foo", b"bar")
         f = BytesIO()
         c.write_to_file(f)
         self.assertEqual(b"[core]\n\tfoo = bar\n", f.getvalue())
 
     def test_write_to_file_subsection(self):
         c = ConfigFile()
         c.set((b"branch", b"blie"), b"foo", b"bar")
         f = BytesIO()
         c.write_to_file(f)
         self.assertEqual(b'[branch "blie"]\n\tfoo = bar\n', f.getvalue())
 
     def test_same_line(self):
         cf = self.from_file(b"[branch.foo] foo = bar\n")
         self.assertEqual(b"bar", cf.get((b"branch", b"foo"), b"foo"))
 
     def test_quoted(self):
         cf = self.from_file(
             b"""[gui]
 \tfontdiff = -family \\\"Ubuntu Mono\\\" -size 11 -overstrike 0
 """
         )
         self.assertEqual(
             ConfigFile(
                 {
                     (b"gui",): {
                         b"fontdiff": b'-family "Ubuntu Mono" -size 11 -overstrike 0',
                     }
                 }
             ),
             cf,
         )
 
     def test_quoted_multiline(self):
         cf = self.from_file(
             b"""[alias]
 who = \"!who() {\\
   git log --no-merges --pretty=format:'%an - %ae' $@ | uniq -c | sort -rn;\\
 };\\
 who\"
 """
         )
         self.assertEqual(
             ConfigFile(
                 {
                     (b"alias",): {
                         b"who": (
                             b"!who() {git log --no-merges --pretty=format:'%an - "
                             b"%ae' $@ | uniq -c | sort -rn;};who"
                         )
                     }
                 }
             ),
             cf,
         )
 
     def test_set_hash_gets_quoted(self):
         c = ConfigFile()
         c.set(b"xandikos", b"color", b"#665544")
         f = BytesIO()
         c.write_to_file(f)
         self.assertEqual(b'[xandikos]\n\tcolor = "#665544"\n', f.getvalue())
 
 
 class ConfigDictTests(TestCase):
     def test_get_set(self):
         cd = ConfigDict()
         self.assertRaises(KeyError, cd.get, b"foo", b"core")
         cd.set((b"core",), b"foo", b"bla")
         self.assertEqual(b"bla", cd.get((b"core",), b"foo"))
         cd.set((b"core",), b"foo", b"bloe")
         self.assertEqual(b"bloe", cd.get((b"core",), b"foo"))
 
     def test_get_boolean(self):
         cd = ConfigDict()
         cd.set((b"core",), b"foo", b"true")
         self.assertTrue(cd.get_boolean((b"core",), b"foo"))
         cd.set((b"core",), b"foo", b"false")
         self.assertFalse(cd.get_boolean((b"core",), b"foo"))
         cd.set((b"core",), b"foo", b"invalid")
         self.assertRaises(ValueError, cd.get_boolean, (b"core",), b"foo")
 
     def test_dict(self):
         cd = ConfigDict()
         cd.set((b"core",), b"foo", b"bla")
         cd.set((b"core2",), b"foo", b"bloe")
 
         self.assertEqual([(b"core",), (b"core2",)], list(cd.keys()))
         self.assertEqual(cd[(b"core",)], {b"foo": b"bla"})
 
         cd[b"a"] = b"b"
         self.assertEqual(cd[b"a"], b"b")
 
     def test_iteritems(self):
         cd = ConfigDict()
         cd.set((b"core",), b"foo", b"bla")
         cd.set((b"core2",), b"foo", b"bloe")
 
         self.assertEqual([(b"foo", b"bla")], list(cd.iteritems((b"core",))))
 
     def test_iteritems_nonexistant(self):
         cd = ConfigDict()
         cd.set((b"core2",), b"foo", b"bloe")
 
         self.assertEqual([], list(cd.iteritems((b"core",))))
 
     def test_itersections(self):
         cd = ConfigDict()
         cd.set((b"core2",), b"foo", b"bloe")
 
         self.assertEqual([(b"core2",)], list(cd.itersections()))
 
 
 class StackedConfigTests(TestCase):
     def setUp(self):
         super(StackedConfigTests, self).setUp()
         self._old_path = os.environ.get("PATH")
 
     def tearDown(self):
         super(StackedConfigTests, self).tearDown()
         os.environ["PATH"] = self._old_path
 
     def test_default_backends(self):
         StackedConfig.default_backends()
 
     @skipIf(sys.platform != "win32", "Windows specfic config location.")
     def test_windows_config_from_path(self):
         from dulwich.config import get_win_system_paths
 
         install_dir = os.path.join("C:", "foo", "Git")
         os.environ["PATH"] = os.path.join(install_dir, "cmd")
         with patch("os.path.exists", return_value=True):
             paths = set(get_win_system_paths())
         self.assertEqual(
             {
                 os.path.join(os.environ.get("PROGRAMDATA"), "Git", "config"),
                 os.path.join(install_dir, "etc", "gitconfig"),
             },
             paths,
         )
 
     @skipIf(sys.platform != "win32", "Windows specfic config location.")
     def test_windows_config_from_reg(self):
         import winreg
 
         from dulwich.config import get_win_system_paths
 
         del os.environ["PATH"]
         install_dir = os.path.join("C:", "foo", "Git")
         with patch("winreg.OpenKey"):
             with patch(
                 "winreg.QueryValueEx",
                 return_value=(install_dir, winreg.REG_SZ),
             ):
                 paths = set(get_win_system_paths())
         self.assertEqual(
             {
                 os.path.join(os.environ.get("PROGRAMDATA"), "Git", "config"),
                 os.path.join(install_dir, "etc", "gitconfig"),
             },
             paths,
         )
 
 
 class EscapeValueTests(TestCase):
     def test_nothing(self):
         self.assertEqual(b"foo", _escape_value(b"foo"))
 
     def test_backslash(self):
         self.assertEqual(b"foo\\\\", _escape_value(b"foo\\"))
 
     def test_newline(self):
         self.assertEqual(b"foo\\n", _escape_value(b"foo\n"))
 
 
 class FormatStringTests(TestCase):
     def test_quoted(self):
         self.assertEqual(b'" foo"', _format_string(b" foo"))
         self.assertEqual(b'"\\tfoo"', _format_string(b"\tfoo"))
 
     def test_not_quoted(self):
         self.assertEqual(b"foo", _format_string(b"foo"))
         self.assertEqual(b"foo bar", _format_string(b"foo bar"))
 
 
 class ParseStringTests(TestCase):
     def test_quoted(self):
         self.assertEqual(b" foo", _parse_string(b'" foo"'))
         self.assertEqual(b"\tfoo", _parse_string(b'"\\tfoo"'))
 
     def test_not_quoted(self):
         self.assertEqual(b"foo", _parse_string(b"foo"))
         self.assertEqual(b"foo bar", _parse_string(b"foo bar"))
 
     def test_nothing(self):
         self.assertEqual(b"", _parse_string(b""))
 
     def test_tab(self):
         self.assertEqual(b"\tbar\t", _parse_string(b"\\tbar\\t"))
 
     def test_newline(self):
         self.assertEqual(b"\nbar\t", _parse_string(b"\\nbar\\t\t"))
 
     def test_quote(self):
         self.assertEqual(b'"foo"', _parse_string(b'\\"foo\\"'))
 
 
 class CheckVariableNameTests(TestCase):
     def test_invalid(self):
         self.assertFalse(_check_variable_name(b"foo "))
         self.assertFalse(_check_variable_name(b"bar,bar"))
         self.assertFalse(_check_variable_name(b"bar.bar"))
 
     def test_valid(self):
         self.assertTrue(_check_variable_name(b"FOO"))
         self.assertTrue(_check_variable_name(b"foo"))
         self.assertTrue(_check_variable_name(b"foo-bar"))
 
 
 class CheckSectionNameTests(TestCase):
     def test_invalid(self):
         self.assertFalse(_check_section_name(b"foo "))
         self.assertFalse(_check_section_name(b"bar,bar"))
 
     def test_valid(self):
         self.assertTrue(_check_section_name(b"FOO"))
         self.assertTrue(_check_section_name(b"foo"))
         self.assertTrue(_check_section_name(b"foo-bar"))
         self.assertTrue(_check_section_name(b"bar.bar"))
 
 
 class SubmodulesTests(TestCase):
     def testSubmodules(self):
         cf = ConfigFile.from_file(
             BytesIO(
                 b"""\
 [submodule "core/lib"]
 \tpath = core/lib
 \turl = https://github.com/phhusson/QuasselC.git
 """
             )
         )
         got = list(parse_submodules(cf))
         self.assertEqual(
             [
                 (
                     b"core/lib",
                     b"https://github.com/phhusson/QuasselC.git",
                     b"core/lib",
                 )
             ],
             got,
         )
diff --git a/dulwich/tests/test_ignore.py b/dulwich/tests/test_ignore.py
index 1e947beb..6cb5c661 100644
--- a/dulwich/tests/test_ignore.py
+++ b/dulwich/tests/test_ignore.py
@@ -1,272 +1,272 @@
 # test_ignore.py -- Tests for ignore files.
 # Copyright (C) 2017 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 ignore files."""
 
 from io import BytesIO
 import os
 import re
 import shutil
 import tempfile
 from dulwich.tests import TestCase
 
 from dulwich.ignore import (
     IgnoreFilter,
     IgnoreFilterManager,
     IgnoreFilterStack,
     Pattern,
     match_pattern,
     read_ignore_patterns,
     translate,
 )
 from dulwich.repo import Repo
 
 
 POSITIVE_MATCH_TESTS = [
     (b"foo.c", b"*.c"),
     (b".c", b"*.c"),
     (b"foo/foo.c", b"*.c"),
     (b"foo/foo.c", b"foo.c"),
     (b"foo.c", b"/*.c"),
     (b"foo.c", b"/foo.c"),
     (b"foo.c", b"foo.c"),
     (b"foo.c", b"foo.[ch]"),
     (b"foo/bar/bla.c", b"foo/**"),
     (b"foo/bar/bla/blie.c", b"foo/**/blie.c"),
     (b"foo/bar/bla.c", b"**/bla.c"),
     (b"bla.c", b"**/bla.c"),
     (b"foo/bar", b"foo/**/bar"),
     (b"foo/bla/bar", b"foo/**/bar"),
     (b"foo/bar/", b"bar/"),
     (b"foo/bar/", b"bar"),
     (b"foo/bar/something", b"foo/bar/*"),
 ]
 
 NEGATIVE_MATCH_TESTS = [
     (b"foo.c", b"foo.[dh]"),
     (b"foo/foo.c", b"/foo.c"),
     (b"foo/foo.c", b"/*.c"),
     (b"foo/bar/", b"/bar/"),
     (b"foo/bar/", b"foo/bar/*"),
     (b"foo/bar", b"foo?bar"),
 ]
 
 
 TRANSLATE_TESTS = [
     (b"*.c", b"(?ms)(.*/)?[^/]*\\.c/?\\Z"),
     (b"foo.c", b"(?ms)(.*/)?foo\\.c/?\\Z"),
     (b"/*.c", b"(?ms)[^/]*\\.c/?\\Z"),
     (b"/foo.c", b"(?ms)foo\\.c/?\\Z"),
     (b"foo.c", b"(?ms)(.*/)?foo\\.c/?\\Z"),
     (b"foo.[ch]", b"(?ms)(.*/)?foo\\.[ch]/?\\Z"),
     (b"bar/", b"(?ms)(.*/)?bar\\/\\Z"),
     (b"foo/**", b"(?ms)foo(/.*)?/?\\Z"),
     (b"foo/**/blie.c", b"(?ms)foo(/.*)?\\/blie\\.c/?\\Z"),
     (b"**/bla.c", b"(?ms)(.*/)?bla\\.c/?\\Z"),
     (b"foo/**/bar", b"(?ms)foo(/.*)?\\/bar/?\\Z"),
     (b"foo/bar/*", b"(?ms)foo\\/bar\\/[^/]+/?\\Z"),
 ]
 
 
 class TranslateTests(TestCase):
     def test_translate(self):
         for (pattern, regex) in TRANSLATE_TESTS:
             if re.escape(b"/") == b"/":
                 # Slash is no longer escaped in Python3.7, so undo the escaping
                 # in the expected return value..
                 regex = regex.replace(b"\\/", b"/")
             self.assertEqual(
                 regex,
                 translate(pattern),
                 "orig pattern: %r, regex: %r, expected: %r"
                 % (pattern, translate(pattern), regex),
             )
 
 
 class ReadIgnorePatterns(TestCase):
     def test_read_file(self):
         f = BytesIO(
             b"""
 # a comment
-
+\x20\x20
 # and an empty line:
 
 \\#not a comment
 !negative
 with trailing whitespace 
 with escaped trailing whitespace\\ 
 """
         )  # noqa: W291
         self.assertEqual(
             list(read_ignore_patterns(f)),
             [
                 b"\\#not a comment",
                 b"!negative",
                 b"with trailing whitespace",
                 b"with escaped trailing whitespace ",
             ],
         )
 
 
 class MatchPatternTests(TestCase):
     def test_matches(self):
         for (path, pattern) in POSITIVE_MATCH_TESTS:
             self.assertTrue(
                 match_pattern(path, pattern),
                 "path: %r, pattern: %r" % (path, pattern),
             )
 
     def test_no_matches(self):
         for (path, pattern) in NEGATIVE_MATCH_TESTS:
             self.assertFalse(
                 match_pattern(path, pattern),
                 "path: %r, pattern: %r" % (path, pattern),
             )
 
 
 class IgnoreFilterTests(TestCase):
     def test_included(self):
         filter = IgnoreFilter([b"a.c", b"b.c"])
         self.assertTrue(filter.is_ignored(b"a.c"))
         self.assertIs(None, filter.is_ignored(b"c.c"))
         self.assertEqual([Pattern(b"a.c")], list(filter.find_matching(b"a.c")))
         self.assertEqual([], list(filter.find_matching(b"c.c")))
 
     def test_included_ignorecase(self):
         filter = IgnoreFilter([b"a.c", b"b.c"], ignorecase=False)
         self.assertTrue(filter.is_ignored(b"a.c"))
         self.assertFalse(filter.is_ignored(b"A.c"))
         filter = IgnoreFilter([b"a.c", b"b.c"], ignorecase=True)
         self.assertTrue(filter.is_ignored(b"a.c"))
         self.assertTrue(filter.is_ignored(b"A.c"))
         self.assertTrue(filter.is_ignored(b"A.C"))
 
     def test_excluded(self):
         filter = IgnoreFilter([b"a.c", b"b.c", b"!c.c"])
         self.assertFalse(filter.is_ignored(b"c.c"))
         self.assertIs(None, filter.is_ignored(b"d.c"))
         self.assertEqual([Pattern(b"!c.c")], list(filter.find_matching(b"c.c")))
         self.assertEqual([], list(filter.find_matching(b"d.c")))
 
     def test_include_exclude_include(self):
         filter = IgnoreFilter([b"a.c", b"!a.c", b"a.c"])
         self.assertTrue(filter.is_ignored(b"a.c"))
         self.assertEqual(
             [Pattern(b"a.c"), Pattern(b"!a.c"), Pattern(b"a.c")],
             list(filter.find_matching(b"a.c")),
         )
 
     def test_manpage(self):
         # A specific example from the gitignore manpage
         filter = IgnoreFilter([b"/*", b"!/foo", b"/foo/*", b"!/foo/bar"])
         self.assertTrue(filter.is_ignored(b"a.c"))
         self.assertTrue(filter.is_ignored(b"foo/blie"))
         self.assertFalse(filter.is_ignored(b"foo"))
         self.assertFalse(filter.is_ignored(b"foo/bar"))
         self.assertFalse(filter.is_ignored(b"foo/bar/"))
         self.assertFalse(filter.is_ignored(b"foo/bar/bloe"))
 
 
 class IgnoreFilterStackTests(TestCase):
     def test_stack_first(self):
         filter1 = IgnoreFilter([b"[a].c", b"[b].c", b"![d].c"])
         filter2 = IgnoreFilter([b"[a].c", b"![b],c", b"[c].c", b"[d].c"])
         stack = IgnoreFilterStack([filter1, filter2])
         self.assertIs(True, stack.is_ignored(b"a.c"))
         self.assertIs(True, stack.is_ignored(b"b.c"))
         self.assertIs(True, stack.is_ignored(b"c.c"))
         self.assertIs(False, stack.is_ignored(b"d.c"))
         self.assertIs(None, stack.is_ignored(b"e.c"))
 
 
 class IgnoreFilterManagerTests(TestCase):
     def test_load_ignore(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
         with open(os.path.join(repo.path, ".gitignore"), "wb") as f:
             f.write(b"/foo/bar\n")
             f.write(b"/dir2\n")
             f.write(b"/dir3/\n")
         os.mkdir(os.path.join(repo.path, "dir"))
         with open(os.path.join(repo.path, "dir", ".gitignore"), "wb") as f:
             f.write(b"/blie\n")
         with open(os.path.join(repo.path, "dir", "blie"), "wb") as f:
             f.write(b"IGNORED")
         p = os.path.join(repo.controldir(), "info", "exclude")
         with open(p, "wb") as f:
             f.write(b"/excluded\n")
         m = IgnoreFilterManager.from_repo(repo)
         self.assertTrue(m.is_ignored("dir/blie"))
         self.assertIs(None, m.is_ignored(os.path.join("dir", "bloe")))
         self.assertIs(None, m.is_ignored("dir"))
         self.assertTrue(m.is_ignored(os.path.join("foo", "bar")))
         self.assertTrue(m.is_ignored(os.path.join("excluded")))
         self.assertTrue(m.is_ignored(os.path.join("dir2", "fileinignoreddir")))
         self.assertFalse(m.is_ignored("dir3"))
         self.assertTrue(m.is_ignored("dir3/"))
         self.assertTrue(m.is_ignored("dir3/bla"))
 
     def test_nested_gitignores(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
 
         with open(os.path.join(repo.path, '.gitignore'), 'wb') as f:
             f.write(b'/*\n')
             f.write(b'!/foo\n')
 
         os.mkdir(os.path.join(repo.path, 'foo'))
         with open(os.path.join(repo.path, 'foo', '.gitignore'), 'wb') as f:
             f.write(b'/bar\n')
 
         with open(os.path.join(repo.path, 'foo', 'bar'), 'wb') as f:
             f.write(b'IGNORED')
         
         m = IgnoreFilterManager.from_repo(repo)
         self.assertTrue(m.is_ignored('foo/bar'))
 
     def test_load_ignore_ignorecase(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
         config = repo.get_config()
         config.set(b"core", b"ignorecase", True)
         config.write_to_path()
         with open(os.path.join(repo.path, ".gitignore"), "wb") as f:
             f.write(b"/foo/bar\n")
             f.write(b"/dir\n")
         m = IgnoreFilterManager.from_repo(repo)
         self.assertTrue(m.is_ignored(os.path.join("dir", "blie")))
         self.assertTrue(m.is_ignored(os.path.join("DIR", "blie")))
 
     def test_ignored_contents(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
         with open(os.path.join(repo.path, ".gitignore"), "wb") as f:
             f.write(b"a/*\n")
             f.write(b"!a/*.txt\n")
         m = IgnoreFilterManager.from_repo(repo)
         os.mkdir(os.path.join(repo.path, "a"))
         self.assertIs(None, m.is_ignored("a"))
         self.assertIs(None, m.is_ignored("a/"))
         self.assertFalse(m.is_ignored("a/b.txt"))
         self.assertTrue(m.is_ignored("a/c.dat"))
diff --git a/dulwich/tests/test_object_store.py b/dulwich/tests/test_object_store.py
index 2e416cff..68789aac 100644
--- a/dulwich/tests/test_object_store.py
+++ b/dulwich/tests/test_object_store.py
@@ -1,784 +1,796 @@
 # 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
 from unittest import skipUnless
 import os
 import shutil
 import stat
+import sys
 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.protocol import DEPTH_INFINITE
 from dulwich.tests import (
     TestCase,
 )
 from dulwich.tests.utils import (
     make_object,
     make_tag,
     build_pack,
 )
 
 try:
     from unittest.mock import patch
 except ImportError:
     patch = None  # type: ignore
 
 
 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})
         )
 
     @skipUnless(patch, "Required mock.patch")
     def test_determine_wants_all_depth(self):
         self.store.add_object(testobject)
         refs = {b"refs/heads/foo": testobject.id}
         with patch.object(self.store, "_get_depth", return_value=1) as m:
             self.assertEqual(
                 [], self.store.determine_wants_all(refs, depth=0)
             )
             self.assertEqual(
                 [testobject.id],
                 self.store.determine_wants_all(refs, depth=DEPTH_INFINITE),
             )
             m.assert_not_called()
 
             self.assertEqual(
                 [], self.store.determine_wants_all(refs, depth=1)
             )
             m.assert_called_with(testobject.id)
             self.assertEqual(
                 [testobject.id], self.store.determine_wants_all(refs, depth=2)
             )
 
     def test_get_depth(self):
         self.assertEqual(
             0, self.store._get_depth(testobject.id)
         )
 
         self.store.add_object(testobject)
         self.assertEqual(
             1, self.store._get_depth(testobject.id, get_parents=lambda x: [])
         )
 
         parent = make_object(Blob, data=b"parent data")
         self.store.add_object(parent)
         self.assertEqual(
             2,
             self.store._get_depth(
                 testobject.id,
                 get_parents=lambda x: [parent.id] if x == testobject else [],
             ),
         )
 
     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_read_alternate_paths(self):
         store = DiskObjectStore(self.store_dir)
 
         abs_path = os.path.abspath(os.path.normpath("/abspath"))
         # ensures in particular existence of the alternates file
         store.add_alternate_path(abs_path)
         self.assertEqual(set(store._read_alternate_paths()), {abs_path})
 
         store.add_alternate_path("relative-path")
         self.assertIn(
             os.path.join(store.path, "relative-path"),
             set(store._read_alternate_paths()),
         )
 
         # arguably, add_alternate_path() could strip comments.
         # Meanwhile it's more convenient to use it than to import INFODIR
         store.add_alternate_path("# comment")
         for alt_path in store._read_alternate_paths():
             self.assertNotIn("#", alt_path)
 
+    def test_file_modes(self):
+        self.store.add_object(testobject)
+        path = self.store._get_shafile_path(testobject.id)
+        mode = os.stat(path).st_mode
+
+        packmode = "0o100444" if sys.platform != "win32" else "0o100666"
+        self.assertEqual(oct(mode), packmode)
+
     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)
+        old_mode = os.stat(path).st_mode
+        os.chmod(path, 0o600)
         with open(path, "wb") as f:  # corrupt the file
             f.write(b"")
+        os.chmod(path, old_mode)
 
         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
 """
                     )
                 )
             ),
         )
diff --git a/dulwich/tests/test_pack.py b/dulwich/tests/test_pack.py
index ded79b24..278259c3 100644
--- a/dulwich/tests/test_pack.py
+++ b/dulwich/tests/test_pack.py
@@ -1,1236 +1,1240 @@
 # test_pack.py -- Tests for the handling of git packs.
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 # 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 Dulwich packs."""
 
 
 from io import BytesIO
 from hashlib import sha1
 import os
 import shutil
+import sys
 import tempfile
 import zlib
 
 from dulwich.errors import (
     ApplyDeltaError,
     ChecksumMismatch,
 )
 from dulwich.file import (
     GitFile,
 )
 from dulwich.object_store import (
     MemoryObjectStore,
 )
 from dulwich.objects import (
     hex_to_sha,
     sha_to_hex,
     Commit,
     Tree,
     Blob,
 )
 from dulwich.pack import (
     OFS_DELTA,
     REF_DELTA,
     MemoryPackIndex,
     Pack,
     PackData,
     apply_delta,
     create_delta,
     deltify_pack_objects,
     load_pack_index,
     UnpackedObject,
     read_zlib_chunks,
     write_pack_header,
     write_pack_index_v1,
     write_pack_index_v2,
     write_pack_object,
     write_pack,
     unpack_object,
     compute_file_sha,
     PackStreamReader,
     DeltaChainIterator,
     _delta_encode_size,
     _encode_copy_operation,
 )
 from dulwich.tests import (
     TestCase,
 )
 from dulwich.tests.utils import (
     make_object,
     build_pack,
 )
 
 pack1_sha = b"bc63ddad95e7321ee734ea11a7a62d314e0d7481"
 
 a_sha = b"6f670c0fb53f9463760b7295fbb814e965fb20c8"
 tree_sha = b"b2a2766a2879c209ab1176e7e778b81ae422eeaa"
 commit_sha = b"f18faa16531ac570a3fdc8c7ca16682548dafd12"
+indexmode = "0o100644" if sys.platform != "win32" else "0o100666"
 
 
 class PackTests(TestCase):
     """Base class for testing packs"""
 
     def setUp(self):
         super(PackTests, self).setUp()
         self.tempdir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, self.tempdir)
 
     datadir = os.path.abspath(os.path.join(os.path.dirname(__file__), "data/packs"))
 
     def get_pack_index(self, sha):
         """Returns a PackIndex from the datadir with the given sha"""
         return load_pack_index(
             os.path.join(self.datadir, "pack-%s.idx" % sha.decode("ascii"))
         )
 
     def get_pack_data(self, sha):
         """Returns a PackData object from the datadir with the given sha"""
         return PackData(
             os.path.join(self.datadir, "pack-%s.pack" % sha.decode("ascii"))
         )
 
     def get_pack(self, sha):
         return Pack(os.path.join(self.datadir, "pack-%s" % sha.decode("ascii")))
 
     def assertSucceeds(self, func, *args, **kwargs):
         try:
             func(*args, **kwargs)
         except ChecksumMismatch as e:
             self.fail(e)
 
 
 class PackIndexTests(PackTests):
     """Class that tests the index of packfiles"""
 
     def test_object_index(self):
         """Tests that the correct object offset is returned from the index."""
         p = self.get_pack_index(pack1_sha)
         self.assertRaises(KeyError, p.object_index, pack1_sha)
         self.assertEqual(p.object_index(a_sha), 178)
         self.assertEqual(p.object_index(tree_sha), 138)
         self.assertEqual(p.object_index(commit_sha), 12)
 
     def test_object_sha1(self):
         """Tests that the correct object offset is returned from the index."""
         p = self.get_pack_index(pack1_sha)
         self.assertRaises(KeyError, p.object_sha1, 876)
         self.assertEqual(p.object_sha1(178), hex_to_sha(a_sha))
         self.assertEqual(p.object_sha1(138), hex_to_sha(tree_sha))
         self.assertEqual(p.object_sha1(12), hex_to_sha(commit_sha))
 
     def test_index_len(self):
         p = self.get_pack_index(pack1_sha)
         self.assertEqual(3, len(p))
 
     def test_get_stored_checksum(self):
         p = self.get_pack_index(pack1_sha)
         self.assertEqual(
             b"f2848e2ad16f329ae1c92e3b95e91888daa5bd01",
             sha_to_hex(p.get_stored_checksum()),
         )
         self.assertEqual(
             b"721980e866af9a5f93ad674144e1459b8ba3e7b7",
             sha_to_hex(p.get_pack_checksum()),
         )
 
     def test_index_check(self):
         p = self.get_pack_index(pack1_sha)
         self.assertSucceeds(p.check)
 
     def test_iterentries(self):
         p = self.get_pack_index(pack1_sha)
         entries = [(sha_to_hex(s), o, c) for s, o, c in p.iterentries()]
         self.assertEqual(
             [
                 (b"6f670c0fb53f9463760b7295fbb814e965fb20c8", 178, None),
                 (b"b2a2766a2879c209ab1176e7e778b81ae422eeaa", 138, None),
                 (b"f18faa16531ac570a3fdc8c7ca16682548dafd12", 12, None),
             ],
             entries,
         )
 
     def test_iter(self):
         p = self.get_pack_index(pack1_sha)
         self.assertEqual(set([tree_sha, commit_sha, a_sha]), set(p))
 
 
 class TestPackDeltas(TestCase):
 
     test_string1 = b"The answer was flailing in the wind"
     test_string2 = b"The answer was falling down the pipe"
     test_string3 = b"zzzzz"
 
     test_string_empty = b""
     test_string_big = b"Z" * 8192
     test_string_huge = b"Z" * 100000
 
     def _test_roundtrip(self, base, target):
         self.assertEqual(
             target, b"".join(apply_delta(base, create_delta(base, target)))
         )
 
     def test_nochange(self):
         self._test_roundtrip(self.test_string1, self.test_string1)
 
     def test_nochange_huge(self):
         self._test_roundtrip(self.test_string_huge, self.test_string_huge)
 
     def test_change(self):
         self._test_roundtrip(self.test_string1, self.test_string2)
 
     def test_rewrite(self):
         self._test_roundtrip(self.test_string1, self.test_string3)
 
     def test_empty_to_big(self):
         self._test_roundtrip(self.test_string_empty, self.test_string_big)
 
     def test_empty_to_huge(self):
         self._test_roundtrip(self.test_string_empty, self.test_string_huge)
 
     def test_huge_copy(self):
         self._test_roundtrip(
             self.test_string_huge + self.test_string1,
             self.test_string_huge + self.test_string2,
         )
 
     def test_dest_overflow(self):
         self.assertRaises(
             ApplyDeltaError,
             apply_delta,
             b"a" * 0x10000,
             b"\x80\x80\x04\x80\x80\x04\x80" + b"a" * 0x10000,
         )
         self.assertRaises(
             ApplyDeltaError, apply_delta, b"", b"\x00\x80\x02\xb0\x11\x11"
         )
 
     def test_pypy_issue(self):
         # Test for https://github.com/jelmer/dulwich/issues/509 /
         # https://bitbucket.org/pypy/pypy/issues/2499/cpyext-pystring_asstring-doesnt-work
         chunks = [
             b"tree 03207ccf58880a748188836155ceed72f03d65d6\n"
             b"parent 408fbab530fd4abe49249a636a10f10f44d07a21\n"
             b"author Victor Stinner <victor.stinner@gmail.com> "
             b"1421355207 +0100\n"
             b"committer Victor Stinner <victor.stinner@gmail.com> "
             b"1421355207 +0100\n"
             b"\n"
             b"Backout changeset 3a06020af8cf\n"
             b"\nStreamWriter: close() now clears the reference to the "
             b"transport\n"
             b"\nStreamWriter now raises an exception if it is closed: "
             b"write(), writelines(),\n"
             b"write_eof(), can_write_eof(), get_extra_info(), drain().\n"
         ]
         delta = [
             b"\xcd\x03\xad\x03]tree ff3c181a393d5a7270cddc01ea863818a8621ca8\n"
             b"parent 20a103cc90135494162e819f98d0edfc1f1fba6b\x91]7\x0510738"
             b"\x91\x99@\x0b10738 +0100\x93\x04\x01\xc9"
         ]
         res = apply_delta(chunks, delta)
         expected = [
             b"tree ff3c181a393d5a7270cddc01ea863818a8621ca8\n"
             b"parent 20a103cc90135494162e819f98d0edfc1f1fba6b",
             b"\nauthor Victor Stinner <victor.stinner@gmail.com> 14213",
             b"10738",
             b" +0100\ncommitter Victor Stinner <victor.stinner@gmail.com> " b"14213",
             b"10738 +0100",
             b"\n\nStreamWriter: close() now clears the reference to the "
             b"transport\n\n"
             b"StreamWriter now raises an exception if it is closed: "
             b"write(), writelines(),\n"
             b"write_eof(), can_write_eof(), get_extra_info(), drain().\n",
         ]
         self.assertEqual(b"".join(expected), b"".join(res))
 
 
 class TestPackData(PackTests):
     """Tests getting the data from the packfile."""
 
     def test_create_pack(self):
         self.get_pack_data(pack1_sha).close()
 
     def test_from_file(self):
         path = os.path.join(self.datadir, "pack-%s.pack" % pack1_sha.decode("ascii"))
         with open(path, "rb") as f:
             PackData.from_file(f, os.path.getsize(path))
 
     def test_pack_len(self):
         with self.get_pack_data(pack1_sha) as p:
             self.assertEqual(3, len(p))
 
     def test_index_check(self):
         with self.get_pack_data(pack1_sha) as p:
             self.assertSucceeds(p.check)
 
     def test_iterobjects(self):
         with self.get_pack_data(pack1_sha) as p:
             commit_data = (
                 b"tree b2a2766a2879c209ab1176e7e778b81ae422eeaa\n"
                 b"author James Westby <jw+debian@jameswestby.net> "
                 b"1174945067 +0100\n"
                 b"committer James Westby <jw+debian@jameswestby.net> "
                 b"1174945067 +0100\n"
                 b"\n"
                 b"Test commit\n"
             )
             blob_sha = b"6f670c0fb53f9463760b7295fbb814e965fb20c8"
             tree_data = b"100644 a\0" + hex_to_sha(blob_sha)
             actual = []
             for offset, type_num, chunks, crc32 in p.iterobjects():
                 actual.append((offset, type_num, b"".join(chunks), crc32))
             self.assertEqual(
                 [
                     (12, 1, commit_data, 3775879613),
                     (138, 2, tree_data, 912998690),
                     (178, 3, b"test 1\n", 1373561701),
                 ],
                 actual,
             )
 
     def test_iterentries(self):
         with self.get_pack_data(pack1_sha) as p:
             entries = {(sha_to_hex(s), o, c) for s, o, c in p.iterentries()}
             self.assertEqual(
                 set(
                     [
                         (
                             b"6f670c0fb53f9463760b7295fbb814e965fb20c8",
                             178,
                             1373561701,
                         ),
                         (
                             b"b2a2766a2879c209ab1176e7e778b81ae422eeaa",
                             138,
                             912998690,
                         ),
                         (
                             b"f18faa16531ac570a3fdc8c7ca16682548dafd12",
                             12,
                             3775879613,
                         ),
                     ]
                 ),
                 entries,
             )
 
     def test_create_index_v1(self):
         with self.get_pack_data(pack1_sha) as p:
             filename = os.path.join(self.tempdir, "v1test.idx")
             p.create_index_v1(filename)
             idx1 = load_pack_index(filename)
             idx2 = self.get_pack_index(pack1_sha)
+            self.assertEqual(oct(os.stat(filename).st_mode), indexmode)
             self.assertEqual(idx1, idx2)
 
     def test_create_index_v2(self):
         with self.get_pack_data(pack1_sha) as p:
             filename = os.path.join(self.tempdir, "v2test.idx")
             p.create_index_v2(filename)
             idx1 = load_pack_index(filename)
             idx2 = self.get_pack_index(pack1_sha)
+            self.assertEqual(oct(os.stat(filename).st_mode), indexmode)
             self.assertEqual(idx1, idx2)
 
     def test_compute_file_sha(self):
         f = BytesIO(b"abcd1234wxyz")
         self.assertEqual(
             sha1(b"abcd1234wxyz").hexdigest(), compute_file_sha(f).hexdigest()
         )
         self.assertEqual(
             sha1(b"abcd1234wxyz").hexdigest(),
             compute_file_sha(f, buffer_size=5).hexdigest(),
         )
         self.assertEqual(
             sha1(b"abcd1234").hexdigest(),
             compute_file_sha(f, end_ofs=-4).hexdigest(),
         )
         self.assertEqual(
             sha1(b"1234wxyz").hexdigest(),
             compute_file_sha(f, start_ofs=4).hexdigest(),
         )
         self.assertEqual(
             sha1(b"1234").hexdigest(),
             compute_file_sha(f, start_ofs=4, end_ofs=-4).hexdigest(),
         )
 
     def test_compute_file_sha_short_file(self):
         f = BytesIO(b"abcd1234wxyz")
         self.assertRaises(AssertionError, compute_file_sha, f, end_ofs=-20)
         self.assertRaises(AssertionError, compute_file_sha, f, end_ofs=20)
         self.assertRaises(
             AssertionError, compute_file_sha, f, start_ofs=10, end_ofs=-12
         )
 
 
 class TestPack(PackTests):
     def test_len(self):
         with self.get_pack(pack1_sha) as p:
             self.assertEqual(3, len(p))
 
     def test_contains(self):
         with self.get_pack(pack1_sha) as p:
             self.assertTrue(tree_sha in p)
 
     def test_get(self):
         with self.get_pack(pack1_sha) as p:
             self.assertEqual(type(p[tree_sha]), Tree)
 
     def test_iter(self):
         with self.get_pack(pack1_sha) as p:
             self.assertEqual(set([tree_sha, commit_sha, a_sha]), set(p))
 
     def test_iterobjects(self):
         with self.get_pack(pack1_sha) as p:
             expected = set([p[s] for s in [commit_sha, tree_sha, a_sha]])
             self.assertEqual(expected, set(list(p.iterobjects())))
 
     def test_pack_tuples(self):
         with self.get_pack(pack1_sha) as p:
             tuples = p.pack_tuples()
             expected = set([(p[s], None) for s in [commit_sha, tree_sha, a_sha]])
             self.assertEqual(expected, set(list(tuples)))
             self.assertEqual(expected, set(list(tuples)))
             self.assertEqual(3, len(tuples))
 
     def test_get_object_at(self):
         """Tests random access for non-delta objects"""
         with self.get_pack(pack1_sha) as p:
             obj = p[a_sha]
             self.assertEqual(obj.type_name, b"blob")
             self.assertEqual(obj.sha().hexdigest().encode("ascii"), a_sha)
             obj = p[tree_sha]
             self.assertEqual(obj.type_name, b"tree")
             self.assertEqual(obj.sha().hexdigest().encode("ascii"), tree_sha)
             obj = p[commit_sha]
             self.assertEqual(obj.type_name, b"commit")
             self.assertEqual(obj.sha().hexdigest().encode("ascii"), commit_sha)
 
     def test_copy(self):
         with self.get_pack(pack1_sha) as origpack:
             self.assertSucceeds(origpack.index.check)
             basename = os.path.join(self.tempdir, "Elch")
             write_pack(basename, origpack.pack_tuples())
 
             with Pack(basename) as newpack:
                 self.assertEqual(origpack, newpack)
                 self.assertSucceeds(newpack.index.check)
                 self.assertEqual(origpack.name(), newpack.name())
                 self.assertEqual(
                     origpack.index.get_pack_checksum(),
                     newpack.index.get_pack_checksum(),
                 )
 
                 wrong_version = origpack.index.version != newpack.index.version
                 orig_checksum = origpack.index.get_stored_checksum()
                 new_checksum = newpack.index.get_stored_checksum()
                 self.assertTrue(wrong_version or orig_checksum == new_checksum)
 
     def test_commit_obj(self):
         with self.get_pack(pack1_sha) as p:
             commit = p[commit_sha]
             self.assertEqual(b"James Westby <jw+debian@jameswestby.net>", commit.author)
             self.assertEqual([], commit.parents)
 
     def _copy_pack(self, origpack):
         basename = os.path.join(self.tempdir, "somepack")
         write_pack(basename, origpack.pack_tuples())
         return Pack(basename)
 
     def test_keep_no_message(self):
         with self.get_pack(pack1_sha) as p:
             p = self._copy_pack(p)
 
         with p:
             keepfile_name = p.keep()
 
         # file should exist
         self.assertTrue(os.path.exists(keepfile_name))
 
         with open(keepfile_name, "r") as f:
             buf = f.read()
             self.assertEqual("", buf)
 
     def test_keep_message(self):
         with self.get_pack(pack1_sha) as p:
             p = self._copy_pack(p)
 
         msg = b"some message"
         with p:
             keepfile_name = p.keep(msg)
 
         # file should exist
         self.assertTrue(os.path.exists(keepfile_name))
 
         # and contain the right message, with a linefeed
         with open(keepfile_name, "rb") as f:
             buf = f.read()
             self.assertEqual(msg + b"\n", buf)
 
     def test_name(self):
         with self.get_pack(pack1_sha) as p:
             self.assertEqual(pack1_sha, p.name())
 
     def test_length_mismatch(self):
         with self.get_pack_data(pack1_sha) as data:
             index = self.get_pack_index(pack1_sha)
             Pack.from_objects(data, index).check_length_and_checksum()
 
             data._file.seek(12)
             bad_file = BytesIO()
             write_pack_header(bad_file, 9999)
             bad_file.write(data._file.read())
             bad_file = BytesIO(bad_file.getvalue())
             bad_data = PackData("", file=bad_file)
             bad_pack = Pack.from_lazy_objects(lambda: bad_data, lambda: index)
             self.assertRaises(AssertionError, lambda: bad_pack.data)
             self.assertRaises(
                 AssertionError, bad_pack.check_length_and_checksum
             )
 
     def test_checksum_mismatch(self):
         with self.get_pack_data(pack1_sha) as data:
             index = self.get_pack_index(pack1_sha)
             Pack.from_objects(data, index).check_length_and_checksum()
 
             data._file.seek(0)
             bad_file = BytesIO(data._file.read()[:-20] + (b"\xff" * 20))
             bad_data = PackData("", file=bad_file)
             bad_pack = Pack.from_lazy_objects(lambda: bad_data, lambda: index)
             self.assertRaises(ChecksumMismatch, lambda: bad_pack.data)
             self.assertRaises(
                 ChecksumMismatch, bad_pack.check_length_and_checksum
             )
 
     def test_iterobjects_2(self):
         with self.get_pack(pack1_sha) as p:
             objs = {o.id: o for o in p.iterobjects()}
             self.assertEqual(3, len(objs))
             self.assertEqual(sorted(objs), sorted(p.index))
             self.assertTrue(isinstance(objs[a_sha], Blob))
             self.assertTrue(isinstance(objs[tree_sha], Tree))
             self.assertTrue(isinstance(objs[commit_sha], Commit))
 
 
 class TestThinPack(PackTests):
     def setUp(self):
         super(TestThinPack, self).setUp()
         self.store = MemoryObjectStore()
         self.blobs = {}
         for blob in (b"foo", b"bar", b"foo1234", b"bar2468"):
             self.blobs[blob] = make_object(Blob, data=blob)
         self.store.add_object(self.blobs[b"foo"])
         self.store.add_object(self.blobs[b"bar"])
 
         # Build a thin pack. 'foo' is as an external reference, 'bar' an
         # internal reference.
         self.pack_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, self.pack_dir)
         self.pack_prefix = os.path.join(self.pack_dir, "pack")
 
         with open(self.pack_prefix + ".pack", "wb") as f:
             build_pack(
                 f,
                 [
                     (REF_DELTA, (self.blobs[b"foo"].id, b"foo1234")),
                     (Blob.type_num, b"bar"),
                     (REF_DELTA, (self.blobs[b"bar"].id, b"bar2468")),
                 ],
                 store=self.store,
             )
 
         # Index the new pack.
         with self.make_pack(True) as pack:
             with PackData(pack._data_path) as data:
                 data.pack = pack
                 data.create_index(self.pack_prefix + ".idx")
 
         del self.store[self.blobs[b"bar"].id]
 
     def make_pack(self, resolve_ext_ref):
         return Pack(
             self.pack_prefix,
             resolve_ext_ref=self.store.get_raw if resolve_ext_ref else None,
         )
 
     def test_get_raw(self):
         with self.make_pack(False) as p:
             self.assertRaises(KeyError, p.get_raw, self.blobs[b"foo1234"].id)
         with self.make_pack(True) as p:
             self.assertEqual((3, b"foo1234"), p.get_raw(self.blobs[b"foo1234"].id))
 
     def test_get_raw_unresolved(self):
         with self.make_pack(False) as p:
             self.assertEqual(
                 (
                     7,
                     b"\x19\x10(\x15f=#\xf8\xb7ZG\xe7\xa0\x19e\xdc\xdc\x96F\x8c",
                     [b"x\x9ccf\x9f\xc0\xccbhdl\x02\x00\x06f\x01l"],
                 ),
                 p.get_raw_unresolved(self.blobs[b"foo1234"].id),
             )
         with self.make_pack(True) as p:
             self.assertEqual(
                 (
                     7,
                     b"\x19\x10(\x15f=#\xf8\xb7ZG\xe7\xa0\x19e\xdc\xdc\x96F\x8c",
                     [b"x\x9ccf\x9f\xc0\xccbhdl\x02\x00\x06f\x01l"],
                 ),
                 p.get_raw_unresolved(self.blobs[b"foo1234"].id),
             )
 
     def test_iterobjects(self):
         with self.make_pack(False) as p:
             self.assertRaises(KeyError, list, p.iterobjects())
         with self.make_pack(True) as p:
             self.assertEqual(
                 sorted(
                     [
                         self.blobs[b"foo1234"].id,
                         self.blobs[b"bar"].id,
                         self.blobs[b"bar2468"].id,
                     ]
                 ),
                 sorted(o.id for o in p.iterobjects()),
             )
 
 
 class WritePackTests(TestCase):
     def test_write_pack_header(self):
         f = BytesIO()
         write_pack_header(f, 42)
         self.assertEqual(b"PACK\x00\x00\x00\x02\x00\x00\x00*", f.getvalue())
 
     def test_write_pack_object(self):
         f = BytesIO()
         f.write(b"header")
         offset = f.tell()
         crc32 = write_pack_object(f, Blob.type_num, b"blob")
         self.assertEqual(crc32, zlib.crc32(f.getvalue()[6:]) & 0xFFFFFFFF)
 
         f.write(b"x")  # unpack_object needs extra trailing data.
         f.seek(offset)
         unpacked, unused = unpack_object(f.read, compute_crc32=True)
         self.assertEqual(Blob.type_num, unpacked.pack_type_num)
         self.assertEqual(Blob.type_num, unpacked.obj_type_num)
         self.assertEqual([b"blob"], unpacked.decomp_chunks)
         self.assertEqual(crc32, unpacked.crc32)
         self.assertEqual(b"x", unused)
 
     def test_write_pack_object_sha(self):
         f = BytesIO()
         f.write(b"header")
         offset = f.tell()
         sha_a = sha1(b"foo")
         sha_b = sha_a.copy()
         write_pack_object(f, Blob.type_num, b"blob", sha=sha_a)
         self.assertNotEqual(sha_a.digest(), sha_b.digest())
         sha_b.update(f.getvalue()[offset:])
         self.assertEqual(sha_a.digest(), sha_b.digest())
 
     def test_write_pack_object_compression_level(self):
         f = BytesIO()
         f.write(b"header")
         offset = f.tell()
         sha_a = sha1(b"foo")
         sha_b = sha_a.copy()
         write_pack_object(f, Blob.type_num, b"blob", sha=sha_a, compression_level=6)
         self.assertNotEqual(sha_a.digest(), sha_b.digest())
         sha_b.update(f.getvalue()[offset:])
         self.assertEqual(sha_a.digest(), sha_b.digest())
 
 
 pack_checksum = hex_to_sha("721980e866af9a5f93ad674144e1459b8ba3e7b7")
 
 
 class BaseTestPackIndexWriting(object):
     def assertSucceeds(self, func, *args, **kwargs):
         try:
             func(*args, **kwargs)
         except ChecksumMismatch as e:
             self.fail(e)
 
     def index(self, filename, entries, pack_checksum):
         raise NotImplementedError(self.index)
 
     def test_empty(self):
         idx = self.index("empty.idx", [], pack_checksum)
         self.assertEqual(idx.get_pack_checksum(), pack_checksum)
         self.assertEqual(0, len(idx))
 
     def test_large(self):
         entry1_sha = hex_to_sha("4e6388232ec39792661e2e75db8fb117fc869ce6")
         entry2_sha = hex_to_sha("e98f071751bd77f59967bfa671cd2caebdccc9a2")
         entries = [
             (entry1_sha, 0xF2972D0830529B87, 24),
             (entry2_sha, (~0xF2972D0830529B87) & (2 ** 64 - 1), 92),
         ]
         if not self._supports_large:
             self.assertRaises(
                 TypeError, self.index, "single.idx", entries, pack_checksum
             )
             return
         idx = self.index("single.idx", entries, pack_checksum)
         self.assertEqual(idx.get_pack_checksum(), pack_checksum)
         self.assertEqual(2, len(idx))
         actual_entries = list(idx.iterentries())
         self.assertEqual(len(entries), len(actual_entries))
         for mine, actual in zip(entries, actual_entries):
             my_sha, my_offset, my_crc = mine
             actual_sha, actual_offset, actual_crc = actual
             self.assertEqual(my_sha, actual_sha)
             self.assertEqual(my_offset, actual_offset)
             if self._has_crc32_checksum:
                 self.assertEqual(my_crc, actual_crc)
             else:
                 self.assertTrue(actual_crc is None)
 
     def test_single(self):
         entry_sha = hex_to_sha("6f670c0fb53f9463760b7295fbb814e965fb20c8")
         my_entries = [(entry_sha, 178, 42)]
         idx = self.index("single.idx", my_entries, pack_checksum)
         self.assertEqual(idx.get_pack_checksum(), pack_checksum)
         self.assertEqual(1, len(idx))
         actual_entries = list(idx.iterentries())
         self.assertEqual(len(my_entries), len(actual_entries))
         for mine, actual in zip(my_entries, actual_entries):
             my_sha, my_offset, my_crc = mine
             actual_sha, actual_offset, actual_crc = actual
             self.assertEqual(my_sha, actual_sha)
             self.assertEqual(my_offset, actual_offset)
             if self._has_crc32_checksum:
                 self.assertEqual(my_crc, actual_crc)
             else:
                 self.assertTrue(actual_crc is None)
 
 
 class BaseTestFilePackIndexWriting(BaseTestPackIndexWriting):
     def setUp(self):
         self.tempdir = tempfile.mkdtemp()
 
     def tearDown(self):
         shutil.rmtree(self.tempdir)
 
     def index(self, filename, entries, pack_checksum):
         path = os.path.join(self.tempdir, filename)
         self.writeIndex(path, entries, pack_checksum)
         idx = load_pack_index(path)
         self.assertSucceeds(idx.check)
         self.assertEqual(idx.version, self._expected_version)
         return idx
 
     def writeIndex(self, filename, entries, pack_checksum):
         # FIXME: Write to BytesIO instead rather than hitting disk ?
         with GitFile(filename, "wb") as f:
             self._write_fn(f, entries, pack_checksum)
 
 
 class TestMemoryIndexWriting(TestCase, BaseTestPackIndexWriting):
     def setUp(self):
         TestCase.setUp(self)
         self._has_crc32_checksum = True
         self._supports_large = True
 
     def index(self, filename, entries, pack_checksum):
         return MemoryPackIndex(entries, pack_checksum)
 
     def tearDown(self):
         TestCase.tearDown(self)
 
 
 class TestPackIndexWritingv1(TestCase, BaseTestFilePackIndexWriting):
     def setUp(self):
         TestCase.setUp(self)
         BaseTestFilePackIndexWriting.setUp(self)
         self._has_crc32_checksum = False
         self._expected_version = 1
         self._supports_large = False
         self._write_fn = write_pack_index_v1
 
     def tearDown(self):
         TestCase.tearDown(self)
         BaseTestFilePackIndexWriting.tearDown(self)
 
 
 class TestPackIndexWritingv2(TestCase, BaseTestFilePackIndexWriting):
     def setUp(self):
         TestCase.setUp(self)
         BaseTestFilePackIndexWriting.setUp(self)
         self._has_crc32_checksum = True
         self._supports_large = True
         self._expected_version = 2
         self._write_fn = write_pack_index_v2
 
     def tearDown(self):
         TestCase.tearDown(self)
         BaseTestFilePackIndexWriting.tearDown(self)
 
 
 class ReadZlibTests(TestCase):
 
     decomp = (
         b"tree 4ada885c9196b6b6fa08744b5862bf92896fc002\n"
         b"parent None\n"
         b"author Jelmer Vernooij <jelmer@samba.org> 1228980214 +0000\n"
         b"committer Jelmer Vernooij <jelmer@samba.org> 1228980214 +0000\n"
         b"\n"
         b"Provide replacement for mmap()'s offset argument."
     )
     comp = zlib.compress(decomp)
     extra = b"nextobject"
 
     def setUp(self):
         super(ReadZlibTests, self).setUp()
         self.read = BytesIO(self.comp + self.extra).read
         self.unpacked = UnpackedObject(Tree.type_num, None, len(self.decomp), 0)
 
     def test_decompress_size(self):
         good_decomp_len = len(self.decomp)
         self.unpacked.decomp_len = -1
         self.assertRaises(ValueError, read_zlib_chunks, self.read, self.unpacked)
         self.unpacked.decomp_len = good_decomp_len - 1
         self.assertRaises(zlib.error, read_zlib_chunks, self.read, self.unpacked)
         self.unpacked.decomp_len = good_decomp_len + 1
         self.assertRaises(zlib.error, read_zlib_chunks, self.read, self.unpacked)
 
     def test_decompress_truncated(self):
         read = BytesIO(self.comp[:10]).read
         self.assertRaises(zlib.error, read_zlib_chunks, read, self.unpacked)
 
         read = BytesIO(self.comp).read
         self.assertRaises(zlib.error, read_zlib_chunks, read, self.unpacked)
 
     def test_decompress_empty(self):
         unpacked = UnpackedObject(Tree.type_num, None, 0, None)
         comp = zlib.compress(b"")
         read = BytesIO(comp + self.extra).read
         unused = read_zlib_chunks(read, unpacked)
         self.assertEqual(b"", b"".join(unpacked.decomp_chunks))
         self.assertNotEqual(b"", unused)
         self.assertEqual(self.extra, unused + read())
 
     def test_decompress_no_crc32(self):
         self.unpacked.crc32 = None
         read_zlib_chunks(self.read, self.unpacked)
         self.assertEqual(None, self.unpacked.crc32)
 
     def _do_decompress_test(self, buffer_size, **kwargs):
         unused = read_zlib_chunks(
             self.read, self.unpacked, buffer_size=buffer_size, **kwargs
         )
         self.assertEqual(self.decomp, b"".join(self.unpacked.decomp_chunks))
         self.assertEqual(zlib.crc32(self.comp), self.unpacked.crc32)
         self.assertNotEqual(b"", unused)
         self.assertEqual(self.extra, unused + self.read())
 
     def test_simple_decompress(self):
         self._do_decompress_test(4096)
         self.assertEqual(None, self.unpacked.comp_chunks)
 
     # These buffer sizes are not intended to be realistic, but rather simulate
     # larger buffer sizes that may end at various places.
     def test_decompress_buffer_size_1(self):
         self._do_decompress_test(1)
 
     def test_decompress_buffer_size_2(self):
         self._do_decompress_test(2)
 
     def test_decompress_buffer_size_3(self):
         self._do_decompress_test(3)
 
     def test_decompress_buffer_size_4(self):
         self._do_decompress_test(4)
 
     def test_decompress_include_comp(self):
         self._do_decompress_test(4096, include_comp=True)
         self.assertEqual(self.comp, b"".join(self.unpacked.comp_chunks))
 
 
 class DeltifyTests(TestCase):
     def test_empty(self):
         self.assertEqual([], list(deltify_pack_objects([])))
 
     def test_single(self):
         b = Blob.from_string(b"foo")
         self.assertEqual(
             [(b.type_num, b.sha().digest(), None, b.as_raw_string())],
             list(deltify_pack_objects([(b, b"")])),
         )
 
     def test_simple_delta(self):
         b1 = Blob.from_string(b"a" * 101)
         b2 = Blob.from_string(b"a" * 100)
         delta = create_delta(b1.as_raw_string(), b2.as_raw_string())
         self.assertEqual(
             [
                 (b1.type_num, b1.sha().digest(), None, b1.as_raw_string()),
                 (b2.type_num, b2.sha().digest(), b1.sha().digest(), delta),
             ],
             list(deltify_pack_objects([(b1, b""), (b2, b"")])),
         )
 
 
 class TestPackStreamReader(TestCase):
     def test_read_objects_emtpy(self):
         f = BytesIO()
         build_pack(f, [])
         reader = PackStreamReader(f.read)
         self.assertEqual(0, len(list(reader.read_objects())))
 
     def test_read_objects(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (Blob.type_num, b"blob"),
                 (OFS_DELTA, (0, b"blob1")),
             ],
         )
         reader = PackStreamReader(f.read)
         objects = list(reader.read_objects(compute_crc32=True))
         self.assertEqual(2, len(objects))
 
         unpacked_blob, unpacked_delta = objects
 
         self.assertEqual(entries[0][0], unpacked_blob.offset)
         self.assertEqual(Blob.type_num, unpacked_blob.pack_type_num)
         self.assertEqual(Blob.type_num, unpacked_blob.obj_type_num)
         self.assertEqual(None, unpacked_blob.delta_base)
         self.assertEqual(b"blob", b"".join(unpacked_blob.decomp_chunks))
         self.assertEqual(entries[0][4], unpacked_blob.crc32)
 
         self.assertEqual(entries[1][0], unpacked_delta.offset)
         self.assertEqual(OFS_DELTA, unpacked_delta.pack_type_num)
         self.assertEqual(None, unpacked_delta.obj_type_num)
         self.assertEqual(
             unpacked_delta.offset - unpacked_blob.offset,
             unpacked_delta.delta_base,
         )
         delta = create_delta(b"blob", b"blob1")
         self.assertEqual(delta, b"".join(unpacked_delta.decomp_chunks))
         self.assertEqual(entries[1][4], unpacked_delta.crc32)
 
     def test_read_objects_buffered(self):
         f = BytesIO()
         build_pack(
             f,
             [
                 (Blob.type_num, b"blob"),
                 (OFS_DELTA, (0, b"blob1")),
             ],
         )
         reader = PackStreamReader(f.read, zlib_bufsize=4)
         self.assertEqual(2, len(list(reader.read_objects())))
 
     def test_read_objects_empty(self):
         reader = PackStreamReader(BytesIO().read)
         self.assertEqual([], list(reader.read_objects()))
 
 
 class TestPackIterator(DeltaChainIterator):
 
     _compute_crc32 = True
 
     def __init__(self, *args, **kwargs):
         super(TestPackIterator, self).__init__(*args, **kwargs)
         self._unpacked_offsets = set()
 
     def _result(self, unpacked):
         """Return entries in the same format as build_pack."""
         return (
             unpacked.offset,
             unpacked.obj_type_num,
             b"".join(unpacked.obj_chunks),
             unpacked.sha(),
             unpacked.crc32,
         )
 
     def _resolve_object(self, offset, pack_type_num, base_chunks):
         assert offset not in self._unpacked_offsets, (
             "Attempted to re-inflate offset %i" % offset
         )
         self._unpacked_offsets.add(offset)
         return super(TestPackIterator, self)._resolve_object(
             offset, pack_type_num, base_chunks
         )
 
 
 class DeltaChainIteratorTests(TestCase):
     def setUp(self):
         super(DeltaChainIteratorTests, self).setUp()
         self.store = MemoryObjectStore()
         self.fetched = set()
 
     def store_blobs(self, blobs_data):
         blobs = []
         for data in blobs_data:
             blob = make_object(Blob, data=data)
             blobs.append(blob)
             self.store.add_object(blob)
         return blobs
 
     def get_raw_no_repeat(self, bin_sha):
         """Wrapper around store.get_raw that doesn't allow repeat lookups."""
         hex_sha = sha_to_hex(bin_sha)
         self.assertFalse(
             hex_sha in self.fetched,
             "Attempted to re-fetch object %s" % hex_sha,
         )
         self.fetched.add(hex_sha)
         return self.store.get_raw(hex_sha)
 
     def make_pack_iter(self, f, thin=None):
         if thin is None:
             thin = bool(list(self.store))
         resolve_ext_ref = thin and self.get_raw_no_repeat or None
         data = PackData("test.pack", file=f)
         return TestPackIterator.for_pack_data(data, resolve_ext_ref=resolve_ext_ref)
 
     def assertEntriesMatch(self, expected_indexes, entries, pack_iter):
         expected = [entries[i] for i in expected_indexes]
         self.assertEqual(expected, list(pack_iter._walk_all_chains()))
 
     def test_no_deltas(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (Commit.type_num, b"commit"),
                 (Blob.type_num, b"blob"),
                 (Tree.type_num, b"tree"),
             ],
         )
         self.assertEntriesMatch([0, 1, 2], entries, self.make_pack_iter(f))
 
     def test_ofs_deltas(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (Blob.type_num, b"blob"),
                 (OFS_DELTA, (0, b"blob1")),
                 (OFS_DELTA, (0, b"blob2")),
             ],
         )
         self.assertEntriesMatch([0, 1, 2], entries, self.make_pack_iter(f))
 
     def test_ofs_deltas_chain(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (Blob.type_num, b"blob"),
                 (OFS_DELTA, (0, b"blob1")),
                 (OFS_DELTA, (1, b"blob2")),
             ],
         )
         self.assertEntriesMatch([0, 1, 2], entries, self.make_pack_iter(f))
 
     def test_ref_deltas(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (1, b"blob1")),
                 (Blob.type_num, (b"blob")),
                 (REF_DELTA, (1, b"blob2")),
             ],
         )
         self.assertEntriesMatch([1, 0, 2], entries, self.make_pack_iter(f))
 
     def test_ref_deltas_chain(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (2, b"blob1")),
                 (Blob.type_num, (b"blob")),
                 (REF_DELTA, (1, b"blob2")),
             ],
         )
         self.assertEntriesMatch([1, 2, 0], entries, self.make_pack_iter(f))
 
     def test_ofs_and_ref_deltas(self):
         # Deltas pending on this offset are popped before deltas depending on
         # this ref.
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (1, b"blob1")),
                 (Blob.type_num, (b"blob")),
                 (OFS_DELTA, (1, b"blob2")),
             ],
         )
         self.assertEntriesMatch([1, 2, 0], entries, self.make_pack_iter(f))
 
     def test_mixed_chain(self):
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (Blob.type_num, b"blob"),
                 (REF_DELTA, (2, b"blob2")),
                 (OFS_DELTA, (0, b"blob1")),
                 (OFS_DELTA, (1, b"blob3")),
                 (OFS_DELTA, (0, b"bob")),
             ],
         )
         self.assertEntriesMatch([0, 2, 4, 1, 3], entries, self.make_pack_iter(f))
 
     def test_long_chain(self):
         n = 100
         objects_spec = [(Blob.type_num, b"blob")]
         for i in range(n):
             objects_spec.append((OFS_DELTA, (i, b"blob" + str(i).encode("ascii"))))
         f = BytesIO()
         entries = build_pack(f, objects_spec)
         self.assertEntriesMatch(range(n + 1), entries, self.make_pack_iter(f))
 
     def test_branchy_chain(self):
         n = 100
         objects_spec = [(Blob.type_num, b"blob")]
         for i in range(n):
             objects_spec.append((OFS_DELTA, (0, b"blob" + str(i).encode("ascii"))))
         f = BytesIO()
         entries = build_pack(f, objects_spec)
         self.assertEntriesMatch(range(n + 1), entries, self.make_pack_iter(f))
 
     def test_ext_ref(self):
         (blob,) = self.store_blobs([b"blob"])
         f = BytesIO()
         entries = build_pack(f, [(REF_DELTA, (blob.id, b"blob1"))], store=self.store)
         pack_iter = self.make_pack_iter(f)
         self.assertEntriesMatch([0], entries, pack_iter)
         self.assertEqual([hex_to_sha(blob.id)], pack_iter.ext_refs())
 
     def test_ext_ref_chain(self):
         (blob,) = self.store_blobs([b"blob"])
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (1, b"blob2")),
                 (REF_DELTA, (blob.id, b"blob1")),
             ],
             store=self.store,
         )
         pack_iter = self.make_pack_iter(f)
         self.assertEntriesMatch([1, 0], entries, pack_iter)
         self.assertEqual([hex_to_sha(blob.id)], pack_iter.ext_refs())
 
     def test_ext_ref_chain_degenerate(self):
         # Test a degenerate case where the sender is sending a REF_DELTA
         # object that expands to an object already in the repository.
         (blob,) = self.store_blobs([b"blob"])
         (blob2,) = self.store_blobs([b"blob2"])
         assert blob.id < blob2.id
 
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (blob.id, b"blob2")),
                 (REF_DELTA, (0, b"blob3")),
             ],
             store=self.store,
         )
         pack_iter = self.make_pack_iter(f)
         self.assertEntriesMatch([0, 1], entries, pack_iter)
         self.assertEqual([hex_to_sha(blob.id)], pack_iter.ext_refs())
 
     def test_ext_ref_multiple_times(self):
         (blob,) = self.store_blobs([b"blob"])
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (blob.id, b"blob1")),
                 (REF_DELTA, (blob.id, b"blob2")),
             ],
             store=self.store,
         )
         pack_iter = self.make_pack_iter(f)
         self.assertEntriesMatch([0, 1], entries, pack_iter)
         self.assertEqual([hex_to_sha(blob.id)], pack_iter.ext_refs())
 
     def test_multiple_ext_refs(self):
         b1, b2 = self.store_blobs([b"foo", b"bar"])
         f = BytesIO()
         entries = build_pack(
             f,
             [
                 (REF_DELTA, (b1.id, b"foo1")),
                 (REF_DELTA, (b2.id, b"bar2")),
             ],
             store=self.store,
         )
         pack_iter = self.make_pack_iter(f)
         self.assertEntriesMatch([0, 1], entries, pack_iter)
         self.assertEqual([hex_to_sha(b1.id), hex_to_sha(b2.id)], pack_iter.ext_refs())
 
     def test_bad_ext_ref_non_thin_pack(self):
         (blob,) = self.store_blobs([b"blob"])
         f = BytesIO()
         build_pack(f, [(REF_DELTA, (blob.id, b"blob1"))], store=self.store)
         pack_iter = self.make_pack_iter(f, thin=False)
         try:
             list(pack_iter._walk_all_chains())
             self.fail()
         except KeyError as e:
             self.assertEqual(([blob.id],), e.args)
 
     def test_bad_ext_ref_thin_pack(self):
         b1, b2, b3 = self.store_blobs([b"foo", b"bar", b"baz"])
         f = BytesIO()
         build_pack(
             f,
             [
                 (REF_DELTA, (1, b"foo99")),
                 (REF_DELTA, (b1.id, b"foo1")),
                 (REF_DELTA, (b2.id, b"bar2")),
                 (REF_DELTA, (b3.id, b"baz3")),
             ],
             store=self.store,
         )
         del self.store[b2.id]
         del self.store[b3.id]
         pack_iter = self.make_pack_iter(f)
         try:
             list(pack_iter._walk_all_chains())
             self.fail()
         except KeyError as e:
             self.assertEqual((sorted([b2.id, b3.id]),), (sorted(e.args[0]),))
 
 
 class DeltaEncodeSizeTests(TestCase):
     def test_basic(self):
         self.assertEqual(b"\x00", _delta_encode_size(0))
         self.assertEqual(b"\x01", _delta_encode_size(1))
         self.assertEqual(b"\xfa\x01", _delta_encode_size(250))
         self.assertEqual(b"\xe8\x07", _delta_encode_size(1000))
         self.assertEqual(b"\xa0\x8d\x06", _delta_encode_size(100000))
 
 
 class EncodeCopyOperationTests(TestCase):
     def test_basic(self):
         self.assertEqual(b"\x80", _encode_copy_operation(0, 0))
         self.assertEqual(b"\x91\x01\x0a", _encode_copy_operation(1, 10))
         self.assertEqual(b"\xb1\x64\xe8\x03", _encode_copy_operation(100, 1000))
         self.assertEqual(b"\x93\xe8\x03\x01", _encode_copy_operation(1000, 1))
diff --git a/dulwich/tests/test_porcelain.py b/dulwich/tests/test_porcelain.py
index 0a0e1882..7717701f 100644
--- a/dulwich/tests/test_porcelain.py
+++ b/dulwich/tests/test_porcelain.py
@@ -1,2738 +1,2738 @@
 # test_porcelain.py -- porcelain tests
 # Copyright (C) 2013 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 dulwich.porcelain."""
 
 from io import BytesIO, StringIO
 import os
 import platform
 import re
 import shutil
 import stat
 import subprocess
 import sys
 import tarfile
 import tempfile
 import time
 from unittest import skipIf
 
 from dulwich import porcelain
 from dulwich.diff_tree import tree_changes
 from dulwich.errors import CommitError
 from dulwich.objects import (
     Blob,
     Tag,
     Tree,
     ZERO_SHA,
 )
 from dulwich.repo import (
     NoIndexPresent,
     Repo,
 )
 from dulwich.tests import (
     TestCase,
 )
 from dulwich.tests.utils import (
     build_commit_graph,
     make_commit,
     make_object,
 )
 
 
 def flat_walk_dir(dir_to_walk):
     for dirpath, _, filenames in os.walk(dir_to_walk):
         rel_dirpath = os.path.relpath(dirpath, dir_to_walk)
         if not dirpath == dir_to_walk:
             yield rel_dirpath
         for filename in filenames:
             if dirpath == dir_to_walk:
                 yield filename
             else:
                 yield os.path.join(rel_dirpath, filename)
 
 
 class PorcelainTestCase(TestCase):
     def setUp(self):
         super(PorcelainTestCase, self).setUp()
         self.test_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, self.test_dir)
         self.repo_path = os.path.join(self.test_dir, "repo")
         self.repo = Repo.init(self.repo_path, mkdir=True)
         self.addCleanup(self.repo.close)
 
 
 class PorcelainGpgTestCase(PorcelainTestCase):
     DEFAULT_KEY = """
 -----BEGIN PGP PRIVATE KEY BLOCK-----
 
 lQVYBGBjIyIBDADAwydvMPQqeEiK54FG1DHwT5sQejAaJOb+PsOhVa4fLcKsrO3F
 g5CxO+/9BHCXAr8xQAtp/gOhDN05fyK3MFyGlL9s+Cd8xf34S3R4rN/qbF0oZmaa
 FW0MuGnniq54HINs8KshadVn1Dhi/GYSJ588qNFRl/qxFTYAk+zaGsgX/QgFfy0f
 djWXJLypZXu9D6DlyJ0cPSzUlfBkI2Ytx6grzIquRjY0FbkjK3l+iGsQ+ebRMdcP
 Sqd5iTN9XuzIUVoBFAZBRjibKV3N2wxlnCbfLlzCyDp7rktzSThzjJ2pVDuLrMAx
 6/L9hIhwmFwdtY4FBFGvMR0b0Ugh3kCsRWr8sgj9I7dUoLHid6ObYhJFhnD3GzRc
 U+xX1uy3iTCqJDsG334aQIhC5Giuxln4SUZna2MNbq65ksh38N1aM/t3+Dc/TKVB
 rb5KWicRPCQ4DIQkHMDCSPyj+dvRLCPzIaPvHD7IrCfHYHOWuvvPGCpwjo0As3iP
 IecoMeguPLVaqgcAEQEAAQAL/i5/pQaUd4G7LDydpbixPS6r9UrfPrU/y5zvBP/p
 DCynPDutJ1oq539pZvXQ2VwEJJy7x0UVKkjyMndJLNWly9wHC7o8jkHx/NalVP47
 LXR+GWbCdOOcYYbdAWcCNB3zOtzPnWhdAEagkc2G9xRQDIB0dLHLCIUpCbLP/CWM
 qlHnDsVMrVTWjgzcpsnyGgw8NeLYJtYGB8dsN+XgCCjo7a9LEvUBKNgdmWBbf14/
 iBw7PCugazFcH9QYfZwzhsi3nqRRagTXHbxFRG0LD9Ro9qCEutHYGP2PJ59Nj8+M
 zaVkJj/OxWxVOGvn2q16mQBCjKpbWfqXZVVl+G5DGOmiSTZqXy+3j6JCKdOMy6Qd
 JBHOHhFZXYmWYaaPzoc33T/C3QhMfY5sOtUDLJmV05Wi4dyBeNBEslYgUuTk/jXb
 5ZAie25eDdrsoqkcnSs2ZguMF7AXhe6il2zVhUUMs/6UZgd6I7I4Is0HXT/pnxEp
 uiTRFu4v8E+u+5a8O3pffe5boQYA3TsIxceen20qY+kRaTOkURHMZLn/y6KLW8bZ
 rNJyXWS9hBAcbbSGhfOwYfzbDCM17yPQO3E2zo8lcGdRklUdIIaCxQwtu36N5dfx
 OLCCQc5LmYdl/EAm91iAhrr7dNntZ18MU09gdzUu+ONZwu4CP3cJT83+qYZULso8
 4Fvd/X8IEfGZ7kM+ylrdqBwtlrn8yYXtom+ows2M2UuNR53B+BUOd73kVLTkTCjE
 JH63+nE8BqG7tDLCMws+23SAA3xxBgDfDrr0x7zCozQKVQEqBzQr9Uoo/c/ZjAfi
 syzNSrDz+g5gqJYtuL9XpPJVWf6V1GXVyJlSbxR9CjTkBxmlPxpvV25IsbVSsh0o
 aqkf2eWpbCL6Qb2E0jd1rvf8sGeTTohzYfiSVVsC2t9ngRO/CmetizwQBvRzLGMZ
 4mtAPiy7ZEDc2dFrPp7zlKISYmJZUx/DJVuZWuOrVMpBP+bSgJXoMTlICxZUqUnE
 2VKVStb/L+Tl8XCwIWdrZb9BaDnHqfcGAM2B4HNPxP88Yj1tEDly/vqeb3vVMhj+
 S1lunnLdgxp46YyuTMYAzj88eCGurRtzBsdxxlGAsioEnZGebEqAHQbieKq/DO6I
 MOMZHMSVBDqyyIx3assGlxSX8BSFW0lhKyT7i0XqnAgCJ9f/5oq0SbFGq+01VQb7
 jIx9PbcYJORxsE0JG/CXXPv27bRtQXsudkWGSYvC0NLOgk4z8+kQpQtyFh16lujq
 WRwMeriu0qNDjCa1/eHIKDovhAZ3GyO5/9m1tBlUZXN0IFVzZXIgPHRlc3RAdGVz
-dC5jb20+iQHUBBMBCAA+FiEEjrR8MQ4fJK44PYMvfN2AClLmXiYFAmBjIyICGwMF
-CQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQfN2AClLmXiZeGQwAoma6
-2OJuX+OROtZR3eK6laY39FS2a8RgA6MTwU0htM4keSWBbDrQD05vUx1D/paD6XEu
-S2OUo8pGsarP6TE3S3yRT4ImHpnt52TiOemMErGCHACmmyDCOkvGV2Sg/pb0zINN
-sBMHMvDYBSZ2Xcvy5LGXbo5C/lja0Jjg5PsCWWuhrAVaNqJ8IqxhiHIy1F2H5RXj
-c++pjl2GyBIDR8IdQlG0EGNNpUgnL1zvUkr5Tbk/H8KJh+PgcBlgip9ocdADcSKI
-ITvxjingp16LGgo2jPpCqyfjp43n71FRJTJbuTqOZzGL9c5DwYoCt1BgX379ZLYx
-luzeGKu3Vz+L8fpM5fiTg35lXSpzw2mJdhVrBSt54oF+kjs0pON93OOW0TF3z8Oi
-1FmJ6bMUHFrxp63/sTnryGCuYFgbWpb0QPP9i9TQvn3aajlLll19JkgoIh750JGh
-QH4JZixX9k32jzr38kzy9RA5FBqhz2egp7Z22uiIhmeR/2zhpFpAdX1uroF9nQVY
-BGBjIyIBDADghIo9wXnRxzfdDTvwnP8dHpLAIaPokgdpyLswqUCixJWiW2xcV6we
-UjEWwH6neN/t1uZYVehbrotxVPla+MPvzhxp6/cmG+2lhzEBOp6zRwnL1wIB6HoK
-JfpREhyMc8rLR0zMso1L1bJTyydvnu07a7BWo3VWKjilb0rEZZUSD/2hidx5HxMO
-JSoidLWed/PPuv6yht3NtA4UThlcfldm9G6PbqCdm1kMEKAkq0wVJvhPJ6gEFRNJ
-imgygfUwMDFXEIhQtxjgdV5Uoz3O5452VLoRsDlgpi3E0WDGj7WXDaO5uSU0T5aJ
-gVgHCP/fxZhHuQFk2YYIl5nCBpOZyWWI0IKmscTuEwzpkhICQDQFvcMZ5ibsl7wA
-2P7YTrQfFDMjjzuaK80GYPfxDFlyKUyLqFt8w/QzsZLDLX7+jxIEpbRAaMw/JsWq
-m5BMxxbS3CIQiS5S3oSKDsNINelqWFfwvLhvlQra8gIxyNTlek25OdgG66BiiX+s
-eH8A/ql+F+MAEQEAAQAL/1jrNSLjMt9pwo6qFKClVQZP2vf7+sH7v7LeHIDXr3En
-YUnVYnOqB1FU5PspTp/+J9W25DB9CZLx7Gj8qeslFdiuLSOoIBB4RCToB3kAoeTH
-0DHqW/GshFTrmJkuDp9zpo/ek6SIXJx5rHAyR9KVw0fizQprH2f6PcgLbTWeM61d
-Juqowmg37eCOyIKv7VQvFqEhYokLD+JNmrvg+Htg0DXGvdjRjAwPf/NezEXpj67a
-6cHTp1/Chwp7pevG+3fTxaCJFesl5/TxxtnaBLE8m2uo/S6Hxgn9l0edonroe1Ql
-TjEqGLy27qi2z5Rem+v6GWNDRgvAWur13v8FNdyduHlioG/NgRsU9mE2MYeFsfi3
-cfNpJQp/wC9PSCIXrb/45mkS8KyjZpCrIPB9RV/m0MREq01TPom7rstZc4A1pD0O
-t7AtUYS3e95zLyEmeLziPJ9fV4fgPmEudDr1uItnmV0LOskKlpg5sc0hhdrwYoob
-fkKt2dx6DqfMlcM1ZkUbLQYA4jwfpFJG4HmYvjL2xCJxM0ycjvMbqFN+4UjgYWVl
-RfOrm1V4Op86FjbRbV6OOCNhznotAg7mul4xtzrrTkK8o3YLBeJseDgl4AWuzXtN
-a9hE0XpK9gJoEHUuBOOsamVh2HpXESFyE5CclOV7JSh541TlZKfnqfZYCg4JSbp0
-UijkawCL5bJJUiGGMD9rZUxIAKQO1DvUEzptS7Jl6S3y5sbIIhilp4KfYWbSk3PP
-u9CnZD5bLhEQp0elxnb/IL8PBgD+DpTeC8unkGKXUpbe9x0ISI6V1D6FmJq/FxNg
-7fMa3QChfGiAyoTm80ZETynj+blRaDO3gY4lTLa3Opubof1EqK2QmwXmpyvXEZNY
-cQfQ2CCSGOWUCK8jEQamUPf1PWndZXJUmROI1WukhlL71V/ir6zQeVCv1wcwPwcl
-JPnAe87upEklnCYpvsEldwHUX9u0BWzoULIEsi+ddtHmT0KTeF/DHRy0W15jIHbj
-Fqhqckj1/6fmr7l7kIi/kN4vWe0F/0Q8IXX+cVMgbl3aIuaGcvENLGcoAsAtPGx8
-8SfRgmfuHK64Y7hx1m+Bo215rxJzZRjqHTBPp0BmCi+JKkaavIBrYRbsx20gveI4
-dzhLcUhBkiT4Q7oz0/VbGHS1CEf9KFeS/YOGj57s4yHauSVI0XdP9kBRTWmXvBkz
-sooB2cKHhwhUN7iiT1k717CiTNUT6Q/pcPFCyNuMoBBGQTU206JEgIjQvI3f8xMU
-MGmGVVQz9/k716ycnhb2JZ/Q/AyQIeHJiQG8BBgBCAAmFiEEjrR8MQ4fJK44PYMv
-fN2AClLmXiYFAmBjIyICGwwFCQPCZwAACgkQfN2AClLmXibetAwAi7KnMpFR2DOu
-JKMa+PyCLpaXFVp/Y3uzGXSmDZJ9PFJ8CzQlY4S61Zkfesq8woTmvk58SSxSgBAp
-UixUK0uFO/s0q5ibODgBXpUQIFW0uhrDpbA08pGunPo/E06Q+5kVocSh9raI1R16
-7ke/FcFd5P7BNuXT1CJW70jcK3jh/L3SFZa+PewKwcgrNkQIg2411vek1VSQB+DP
-URb/OCqD7gFkj1/BaQgMxO1tZUx9tIt/YuwqnxIOOxjnD13aRinZ2bK1SEsG/dyx
-y19ZB0d6d7eTGdYNWIAClHbnzbsEm5QzcYsDBqGiRS6Je38Wc5qD+z0h/R1GJXjW
-d9QAenkb7v9v10yLZH0udW8PY5OQ5IjtcUMVppvAn5ZWsApw/eCFEEsvcNuYSnY2
-FO+dmjq6Fc8XdqR12jaSaiaSFIdhkTN83HSdZ/luDBqP4mVDLhRnOkLnDZF1HDeR
-BcZYEcqkDeW64mdTo65ILOPQ+HMCK12AnnBsbyfbsWAUczkQ7GVq
-=YPjc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+=ivA/
 -----END PGP PRIVATE KEY BLOCK-----
     """
 
     DEFAULT_KEY_ID = "8EB47C310E1F24AE383D832F7CDD800A52E65E26"
 
     NON_DEFAULT_KEY = """
 -----BEGIN PGP PRIVATE KEY BLOCK-----
 
 lQVYBGBjI0ABDADGWBRp+t02emfzUlhrc1psqIhhecFm6Em0Kv33cfDpnfoMF1tK
 Yy/4eLYIR7FmpdbFPcDThFNHbXJzBi00L1mp0XQE2l50h/2bDAAgREdZ+NVo5a7/
 RSZjauNU1PxW6pnXMehEh1tyIQmV78jAukaakwaicrpIenMiFUN3fAKHnLuFffA6
 t0f3LqJvTDhUw/o2vPgw5e6UDQhA1C+KTv1KXVrhJNo88a3hZqCZ76z3drKR411Q
 zYgT4DUb8lfnbN+z2wfqT9oM5cegh2k86/mxAA3BYOeQrhmQo/7uhezcgbxtdGZr
 YlbuaNDTSBrn10ZoaxLPo2dJe2zWxgD6MpvsGU1w3tcRW508qo/+xoWp2/pDzmok
 +uhOh1NAj9zB05VWBz1r7oBgCOIKpkD/LD4VKq59etsZ/UnrYDwKdXWZp7uhshkU
 M7N35lUJcR76a852dlMdrgpmY18+BP7+o7M+5ElHTiqQbMuE1nHTg8RgVpdV+tUx
 dg6GWY/XHf5asm8AEQEAAQAL/A85epOp+GnymmEQfI3+5D178D//Lwu9n86vECB6
 xAHCqQtdjZnXpDp/1YUsL59P8nzgYRk7SoMskQDoQ/cB/XFuDOhEdMSgHaTVlnrj
 ktCCq6rqGnUosyolbb64vIfVaSqd/5SnCStpAsnaBoBYrAu4ZmV4xfjDQWwn0q5s
 u+r56mD0SkjPgbwk/b3qTVagVmf2OFzUgWwm1e/X+bA1oPag1NV8VS4hZPXswT4f
 qhiyqUFOgP6vUBcqehkjkIDIl/54xII7/P5tp3LIZawvIXqHKNTqYPCqaCqCj+SL
 vMYDIb6acjescfZoM71eAeHAANeFZzr/rwfBT+dEP6qKmPXNcvgE11X44ZCr04nT
 zOV/uDUifEvKT5qgtyJpSFEVr7EXubJPKoNNhoYqq9z1pYU7IedX5BloiVXKOKTY
 0pk7JkLqf3g5fYtXh/wol1owemITJy5V5PgaqZvk491LkI6S+kWC7ANYUg+TDPIW
 afxW3E5N1CYV6XDAl0ZihbLcoQYAy0Ky/p/wayWKePyuPBLwx9O89GSONK2pQljZ
 yaAgxPQ5/i1vx6LIMg7k/722bXR9W3zOjWOin4eatPM3d2hkG96HFvnBqXSmXOPV
 03Xqy1/B5Tj8E9naLKUHE/OBQEc363DgLLG9db5HfPlpAngeppYPdyWkhzXyzkgS
 PylaE5eW3zkdjEbYJ6RBTecTZEgBaMvJNPdWbn//frpP7kGvyiCg5Es+WjLInUZ6
 0sdifcNTCewzLXK80v/y5mVOdJhPBgD5zs9cYdyiQJayqAuOr+He1eMHMVUbm9as
 qBmPrst398eBW9ZYF7eBfTSlUf6B+WnvyLKEGsUf/7IK0EWDlzoBuWzWiHjUAY1g
 m9eTV2MnvCCCefqCErWwfFo2nWOasAZA9sKD+ICIBY4tbtvSl4yfLBzTMwSvs9ZS
 K1ocPSYUnhm2miSWZ8RLZPH7roHQasNHpyq/AX7DahFf2S/bJ+46ZGZ8Pigr7hA+
 MjmpQ4qVdb5SaViPmZhAKO+PjuCHm+EF/2H0Y3Sl4eXgxZWoQVOUeXdWg9eMfYrj
 XDtUMIFppV/QxbeztZKvJdfk64vt/crvLsOp0hOky9cKwY89r4QaHfexU3qR+qDq
 UlMvR1rHk7dS5HZAtw0xKsFJNkuDxvBkMqv8Los8zp3nUl+U99dfZOArzNkW38wx
 FPa0ixkC9za2BkDrWEA8vTnxw0A2upIFegDUhwOByrSyfPPnG3tKGeqt3Izb/kDk
 Q9vmo+HgxBOguMIvlzbBfQZwtbd/gXzlvPqCtCJBbm90aGVyIFRlc3QgVXNlciA8
-dGVzdDJAdGVzdC5jb20+iQHUBBMBCAA+FiEEapM5P1DF5qzT1vtFuTYhLttOFMAF
-AmBjI0ACGwMFCQPCZwAFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQuTYhLttO
-FMBRlAwAwVQJbAhR39vlSKh2ksjZvM+dZhNEP0UVtE+5D0Ukx3OHPY+zqe6Orkf9
-FgXY0h6byr6gudsEnBs4wZ7LgJDiBY/qQBtq93Fy/hZurvDTsMdv9qpSjDroCfTO
-O1Q40aqlucoaTjtIGwFNXRmd6Xi9IB+dGnFgM0l68MXhkSVnj0LfAK5UxdIQ/4tq
-MdE0pWn1x+ebdjpBHO6Q4XY+vXfSqO2rOg3uxL54GR9IqNeWUNqIMvNyBO0XkGq5
-93bCi4s1dDr101RQsb6MQxYDdZ5tdChyXBQnx5nMWaUALm0GRF8FoFEB4oMoF5gD
-2nqSCdnMNVkWich46xvL2h10EzOujvaob+c4FZc+n8gk5GnkuigMOqMJ1xY/QrC6
-Ce//RHm2k0NoEPFQaRsHJIQxwZZwmHkzREDnfeEj8hSExM1anQirmIsMtI8knD/8
-Vl9HzNfeLCDPtcC28a1vXjsJCF7j4LRInpSgDzovFdARYvCs6equsb3UYRA17O9W
-bVHhX54dnQVXBGBjI0ABDADJMBYIcG0Yil9YxFs7aYzNbd7alUAr89VbY8eIGPHP
-3INFPM1wlBQCu+4j6xdEbhMpppLBZ9A5TEylP4C6qLtPa+oLtPeuSw8gHDE10XE4
-lbgPs376rL60XdImSOHhiduACUefYjqpcmFH9Bim1CC+koArYrSQJQx1Jri+OpnT
-aL/8UID0KzD/kEgMVGlHIVj9oJmb4+j9pW8I/g0wDSnIaEKFMxqu6SIVJ1GWj+MU
-MvZigjLCsNCZd7PnbOC5VeU3SsXj6he74Jx0AmGMPWIHi9M0DjHO5d1cCbXTnud8
-xxM1bOh47aCTnMK5cVyIr+adihgJpVVhrndSM8aklBPRgtozrGNCgF2CkYU2P1bl
-xfloNr/8UZpM83o+s1aObBszzRNLxnpNORqoLqjfPtLEPQnagxE+4EapCq0NZ/x6
-yO5VTwwpNljdFAEk40uGuKyn1QA3uNMHy5DlpLl+tU7t1KEovdZ+OVYsYKZhVzw0
-MTpKogk9JI7AN0q62ronPskAEQEAAQAL+O8BUSt1ZCVjPSIXIsrR+ZOSkszZwgJ1
-CWIoh0IHYD2vmcMHGIhFYgBdgerpvhptKhaw7GcXDScEnYkyh5s4GE2hxclik1tb
-j/x1gYCN8BNoyeDdPFxQG73qN12D99QYEctpOsz9xPLIDwmL0j1ehAfhwqHIAPm9
-Ca+i8JYMx/F+35S/jnKDXRI+NVlwbiEyXKXxxIqNlpy9i8sDBGexO5H5Sg0zSN/B
-1duLekGDbiDw6gLc6bCgnS+0JOUpU07Z2fccMOY9ncjKGD2uIb/ePPUaek92GCQy
-q0eorCIVbrcQsRc5sSsNtnRKQTQtxioROeDg7kf2oWySeHTswlXW/219ihrSXgte
-HJd+rPm7DYLEeGLRny8bRKv8rQdAtApHaJE4dAATXeY4RYo4NlXHYaztGYtU6kiM
-/3zCfWAe9Nn+Wh9jMTZrjefUCagS5r6ZqAh7veNo/vgIGaCLh0a1Ypa0Yk9KFrn3
-LYEM3zgk3m3bn+7qgy5cUYXoJ3DGJJEhBgDPonpW0WElqLs5ZMem1ha85SC38F0I
-kAaSuzuzv3eORiKWuyJGF32Q2XHa1RHQs1JtUKd8rxFer3b8Oq71zLz6JtVc9dmR
-udvgcJYX0PC11F6WGjZFSSp39dajFp0A5DKUs39F3w7J1yuDM56TDIN810ywufGA
-HARY1pZbUJAy/dTqjFnCbNjpAakor3hVzqxcmUG+7Y2X9c2AGncT1MqAQC3M8JZc
-uZvkK8A9cMk8B914ryYE7VsZMdMhyTwHmykGAPgNLLa3RDETeGeGCKWI+ZPOoU0i
-b5JtJZ1dP3tNwfZKuZBZXKW9gqYqyBa/qhMip84SP30pr/TvulcdAFC759HK8sQZ
-yJ6Vw24Pc+5ssRxrQUEw1rvJPWhmQCmCOZHBMQl5T6eaTOpR5u3aUKTMlxPKhK9e
-C1dCSTnI/nyL8An3VKnLy+K/LI42YGphBVLLJmBewuTVDIJviWRdntiG8dElyEJM
-OywUltk32CEmqgsD9tPO8rXZjnMrMn3gfsiaoQYA6/6/e2utkHr7gAoWBgrBBdqV
-Hsvqh5Ro2DjLAOpZItO/EdCJfDAmbTYOa04535sBDP2tcH/vipPOPpbr1Y9Y/mNs
-KCulNxedyqAmEkKOcerLUP5UHju0AB6VBjHJFdU2mqT+UjPyBk7WeKXgFomyoYMv
-3KpNOFWRxi0Xji4kKHbttA6Hy3UcGPr9acyUAlDYeKmxbSUYIPhw32bbGrX9+F5Y
-riTufRsG3jftQVo9zqdcQSD/5pUTMn3EYbEcohYB2YWJAbwEGAEIACYWIQRqkzk/
-UMXmrNPW+0W5NiEu204UwAUCYGMjQAIbDAUJA8JnAAAKCRC5NiEu204UwDICC/9o
-q0illSIAuBHCImbNcOAJmno6ZZ1OkqtQrEmmKjIxUEkMZDvEaAUuGwCyfn3RcaWQ
-m3HAv0HRtYiBebN9rgfMGEEp9prmTuAOxc4vWfMOoYgo2vLNfaKwLREHrm7NzHSo
-ovb+ZwWpm724DU6IMdaVpc5LzBPArG0nUcOTZ15Lc2akpbhFjxBHKKimkk0V1YwU
-lIyn7I5wHbJ5qz1YjaCjUYi6xLwHDxStIE2vR2dzHiVKNZBKfhRd7BIYfpBEvNGS
-RKR1moy3QUKw71Q1fE+TcbK6eFsbjROxq2OZSTy371zG9hLccroM0cZl8pBlnRpX
-sn3g7h5kZVzZ0VnOM3A8f29v0P9LE6r+p4oaWnBh9QuNq50hYPyA6CJNF73A+Shc
-AanKpb2pqswnk1CVhAzh+l7JhOR5RUVOMCv9mb3TwYQcE7qhMovHWhLmpFhlfO4a
-+AMn3f/774DKYGUigIzR45dhZFFkGvvb85uEP67GqgSv/zTISviuuc4A6Ze9ALs=
-=kOKh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+=9zU5
 -----END PGP PRIVATE KEY BLOCK-----
 """
 
     NON_DEFAULT_KEY_ID = "6A93393F50C5E6ACD3D6FB45B936212EDB4E14C0"
 
     def setUp(self):
         super(PorcelainGpgTestCase, self).setUp()
         self.gpg_dir = os.path.join(self.test_dir, "gpg")
         os.mkdir(self.gpg_dir, mode=0o700)
         self.addCleanup(shutil.rmtree, self.gpg_dir)
         self._old_gnupghome = os.environ.get("GNUPGHOME")
         os.environ["GNUPGHOME"] = self.gpg_dir
         if self._old_gnupghome is None:
             self.addCleanup(os.environ.__delitem__, "GNUPGHOME")
         else:
             self.addCleanup(os.environ.__setitem__, "GNUPGHOME", self._old_gnupghome)
 
     def import_default_key(self):
         subprocess.run(
             ["gpg", "--import"],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             input=PorcelainGpgTestCase.DEFAULT_KEY,
             universal_newlines=True,
         )
 
     def import_non_default_key(self):
         subprocess.run(
             ["gpg", "--import"],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             input=PorcelainGpgTestCase.NON_DEFAULT_KEY,
             universal_newlines=True,
         )
 
 
 class ArchiveTests(PorcelainTestCase):
     """Tests for the archive command."""
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"refs/heads/master"] = c3.id
         out = BytesIO()
         err = BytesIO()
         porcelain.archive(
             self.repo.path, b"refs/heads/master", outstream=out, errstream=err
         )
         self.assertEqual(b"", err.getvalue())
         tf = tarfile.TarFile(fileobj=out)
         self.addCleanup(tf.close)
         self.assertEqual([], tf.getnames())
 
 
 class UpdateServerInfoTests(PorcelainTestCase):
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"refs/heads/foo"] = c3.id
         porcelain.update_server_info(self.repo.path)
         self.assertTrue(
             os.path.exists(os.path.join(self.repo.controldir(), "info", "refs"))
         )
 
 
 class CommitTests(PorcelainTestCase):
     def test_custom_author(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"refs/heads/foo"] = c3.id
         sha = porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
         self.assertTrue(isinstance(sha, bytes))
         self.assertEqual(len(sha), 40)
 
     def test_unicode(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"refs/heads/foo"] = c3.id
         sha = porcelain.commit(
             self.repo.path,
             message="Some message",
             author="Joe <joe@example.com>",
             committer="Bob <bob@example.com>",
         )
         self.assertTrue(isinstance(sha, bytes))
         self.assertEqual(len(sha), 40)
 
     def test_no_verify(self):
         if os.name != "posix":
             self.skipTest("shell hook tests requires POSIX shell")
         self.assertTrue(os.path.exists("/bin/sh"))
 
         hooks_dir = os.path.join(self.repo.controldir(), "hooks")
         os.makedirs(hooks_dir, exist_ok=True)
         self.addCleanup(shutil.rmtree, hooks_dir)
 
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
 
         hook_fail = "#!/bin/sh\nexit 1"
 
         # hooks are executed in pre-commit, commit-msg order
         # test commit-msg failure first, then pre-commit failure, then
         # no_verify to skip both hooks
         commit_msg = os.path.join(hooks_dir, "commit-msg")
         with open(commit_msg, "w") as f:
             f.write(hook_fail)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         with self.assertRaises(CommitError):
             porcelain.commit(
                 self.repo.path,
                 message="Some message",
                 author="Joe <joe@example.com>",
                 committer="Bob <bob@example.com>",
             )
 
         pre_commit = os.path.join(hooks_dir, "pre-commit")
         with open(pre_commit, "w") as f:
             f.write(hook_fail)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         with self.assertRaises(CommitError):
             porcelain.commit(
                 self.repo.path,
                 message="Some message",
                 author="Joe <joe@example.com>",
                 committer="Bob <bob@example.com>",
             )
 
         sha = porcelain.commit(
             self.repo.path,
             message="Some message",
             author="Joe <joe@example.com>",
             committer="Bob <bob@example.com>",
             no_verify=True,
         )
         self.assertTrue(isinstance(sha, bytes))
         self.assertEqual(len(sha), 40)
 
 
 class CleanTests(PorcelainTestCase):
     def put_files(self, tracked, ignored, untracked, empty_dirs):
         """Put the described files in the wd"""
         all_files = tracked | ignored | untracked
         for file_path in all_files:
             abs_path = os.path.join(self.repo.path, file_path)
             # File may need to be written in a dir that doesn't exist yet, so
             # create the parent dir(s) as necessary
             parent_dir = os.path.dirname(abs_path)
             try:
                 os.makedirs(parent_dir)
             except FileExistsError:
                 pass
             with open(abs_path, "w") as f:
                 f.write("")
 
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.writelines(ignored)
 
         for dir_path in empty_dirs:
             os.mkdir(os.path.join(self.repo.path, "empty_dir"))
 
         files_to_add = [os.path.join(self.repo.path, t) for t in tracked]
         porcelain.add(repo=self.repo.path, paths=files_to_add)
         porcelain.commit(repo=self.repo.path, message="init commit")
 
     def assert_wd(self, expected_paths):
         """Assert paths of files and dirs in wd are same as expected_paths"""
         control_dir_rel = os.path.relpath(self.repo._controldir, self.repo.path)
 
         # normalize paths to simplify comparison across platforms
         found_paths = {
             os.path.normpath(p)
             for p in flat_walk_dir(self.repo.path)
             if not p.split(os.sep)[0] == control_dir_rel
         }
         norm_expected_paths = {os.path.normpath(p) for p in expected_paths}
         self.assertEqual(found_paths, norm_expected_paths)
 
     def test_from_root(self):
         self.put_files(
             tracked={"tracked_file", "tracked_dir/tracked_file", ".gitignore"},
             ignored={"ignored_file"},
             untracked={
                 "untracked_file",
                 "tracked_dir/untracked_dir/untracked_file",
                 "untracked_dir/untracked_dir/untracked_file",
             },
             empty_dirs={"empty_dir"},
         )
 
         porcelain.clean(repo=self.repo.path, target_dir=self.repo.path)
 
         self.assert_wd(
             {
                 "tracked_file",
                 "tracked_dir/tracked_file",
                 ".gitignore",
                 "ignored_file",
                 "tracked_dir",
             }
         )
 
     def test_from_subdir(self):
         self.put_files(
             tracked={"tracked_file", "tracked_dir/tracked_file", ".gitignore"},
             ignored={"ignored_file"},
             untracked={
                 "untracked_file",
                 "tracked_dir/untracked_dir/untracked_file",
                 "untracked_dir/untracked_dir/untracked_file",
             },
             empty_dirs={"empty_dir"},
         )
 
         porcelain.clean(
             repo=self.repo,
             target_dir=os.path.join(self.repo.path, "untracked_dir"),
         )
 
         self.assert_wd(
             {
                 "tracked_file",
                 "tracked_dir/tracked_file",
                 ".gitignore",
                 "ignored_file",
                 "untracked_file",
                 "tracked_dir/untracked_dir/untracked_file",
                 "empty_dir",
                 "untracked_dir",
                 "tracked_dir",
                 "tracked_dir/untracked_dir",
             }
         )
 
 
 class CloneTests(PorcelainTestCase):
     def test_simple_local(self):
         f1_1 = make_object(Blob, data=b"f1")
         commit_spec = [[1], [2, 1], [3, 1, 2]]
         trees = {
             1: [(b"f1", f1_1), (b"f2", f1_1)],
             2: [(b"f1", f1_1), (b"f2", f1_1)],
             3: [(b"f1", f1_1), (b"f2", f1_1)],
         }
 
         c1, c2, c3 = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c3.id
         self.repo.refs[b"refs/tags/foo"] = c3.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         r = porcelain.clone(
             self.repo.path, target_path, checkout=False, errstream=errstream
         )
         self.addCleanup(r.close)
         self.assertEqual(r.path, target_path)
         target_repo = Repo(target_path)
         self.assertEqual(0, len(target_repo.open_index()))
         self.assertEqual(c3.id, target_repo.refs[b"refs/tags/foo"])
         self.assertTrue(b"f1" not in os.listdir(target_path))
         self.assertTrue(b"f2" not in os.listdir(target_path))
         c = r.get_config()
         encoded_path = self.repo.path
         if not isinstance(encoded_path, bytes):
             encoded_path = encoded_path.encode("utf-8")
         self.assertEqual(encoded_path, c.get((b"remote", b"origin"), b"url"))
         self.assertEqual(
             b"+refs/heads/*:refs/remotes/origin/*",
             c.get((b"remote", b"origin"), b"fetch"),
         )
 
     def test_simple_local_with_checkout(self):
         f1_1 = make_object(Blob, data=b"f1")
         commit_spec = [[1], [2, 1], [3, 1, 2]]
         trees = {
             1: [(b"f1", f1_1), (b"f2", f1_1)],
             2: [(b"f1", f1_1), (b"f2", f1_1)],
             3: [(b"f1", f1_1), (b"f2", f1_1)],
         }
 
         c1, c2, c3 = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c3.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         with porcelain.clone(
             self.repo.path, target_path, checkout=True, errstream=errstream
         ) as r:
             self.assertEqual(r.path, target_path)
         with Repo(target_path) as r:
             self.assertEqual(r.head(), c3.id)
         self.assertTrue("f1" in os.listdir(target_path))
         self.assertTrue("f2" in os.listdir(target_path))
 
     def test_bare_local_with_checkout(self):
         f1_1 = make_object(Blob, data=b"f1")
         commit_spec = [[1], [2, 1], [3, 1, 2]]
         trees = {
             1: [(b"f1", f1_1), (b"f2", f1_1)],
             2: [(b"f1", f1_1), (b"f2", f1_1)],
             3: [(b"f1", f1_1), (b"f2", f1_1)],
         }
 
         c1, c2, c3 = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c3.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         with porcelain.clone(
             self.repo.path, target_path, bare=True, errstream=errstream
         ) as r:
             self.assertEqual(r.path, target_path)
         with Repo(target_path) as r:
             r.head()
             self.assertRaises(NoIndexPresent, r.open_index)
         self.assertFalse(b"f1" in os.listdir(target_path))
         self.assertFalse(b"f2" in os.listdir(target_path))
 
     def test_no_checkout_with_bare(self):
         f1_1 = make_object(Blob, data=b"f1")
         commit_spec = [[1]]
         trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
 
         (c1,) = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c1.id
         self.repo.refs[b"HEAD"] = c1.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         self.assertRaises(
             porcelain.Error,
             porcelain.clone,
             self.repo.path,
             target_path,
             checkout=True,
             bare=True,
             errstream=errstream,
         )
 
     def test_no_head_no_checkout(self):
         f1_1 = make_object(Blob, data=b"f1")
         commit_spec = [[1]]
         trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
 
         (c1,) = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c1.id
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
         errstream = BytesIO()
         r = porcelain.clone(
             self.repo.path, target_path, checkout=True, errstream=errstream
         )
         r.close()
 
     def test_no_head_no_checkout_outstream_errstream_autofallback(self):
         f1_1 = make_object(Blob, data=b"f1")
         commit_spec = [[1]]
         trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
 
         (c1,) = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c1.id
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
         errstream = porcelain.NoneStream()
         r = porcelain.clone(
             self.repo.path, target_path, checkout=True, errstream=errstream
         )
         r.close()
 
     def test_source_broken(self):
         target_path = tempfile.mkdtemp()
         self.assertRaises(Exception, porcelain.clone, "/nonexistant/repo", target_path)
         self.assertFalse(os.path.exists(target_path))
 
     def test_fetch_symref(self):
         f1_1 = make_object(Blob, data=b"f1")
         trees = {1: [(b"f1", f1_1), (b"f2", f1_1)]}
         [c1] = build_commit_graph(self.repo.object_store, [[1]], trees)
         self.repo.refs.set_symbolic_ref(b"HEAD", b"refs/heads/else")
         self.repo.refs[b"refs/heads/else"] = c1.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         r = porcelain.clone(
             self.repo.path, target_path, checkout=False, errstream=errstream
         )
         self.addCleanup(r.close)
         self.assertEqual(r.path, target_path)
         target_repo = Repo(target_path)
         self.assertEqual(0, len(target_repo.open_index()))
         self.assertEqual(c1.id, target_repo.refs[b"refs/heads/else"])
         self.assertEqual(c1.id, target_repo.refs[b"HEAD"])
         self.assertEqual({b"HEAD": b"refs/heads/else"}, target_repo.refs.get_symrefs())
 
 
 class InitTests(TestCase):
     def test_non_bare(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         porcelain.init(repo_dir)
 
     def test_bare(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         porcelain.init(repo_dir, bare=True)
 
 
 class AddTests(PorcelainTestCase):
     def test_add_default_paths(self):
         # create a file for initial commit
         fullpath = os.path.join(self.repo.path, "blah")
         with open(fullpath, "w") as f:
             f.write("\n")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test",
             author=b"test <email>",
             committer=b"test <email>",
         )
 
         # Add a second test file and a file in a directory
         with open(os.path.join(self.repo.path, "foo"), "w") as f:
             f.write("\n")
         os.mkdir(os.path.join(self.repo.path, "adir"))
         with open(os.path.join(self.repo.path, "adir", "afile"), "w") as f:
             f.write("\n")
         cwd = os.getcwd()
         try:
             os.chdir(self.repo.path)
             self.assertEqual(set(["foo", "blah", "adir", ".git"]), set(os.listdir(".")))
             self.assertEqual(
                 (["foo", os.path.join("adir", "afile")], set()),
                 porcelain.add(self.repo.path),
             )
         finally:
             os.chdir(cwd)
 
         # Check that foo was added and nothing in .git was modified
         index = self.repo.open_index()
         self.assertEqual(sorted(index), [b"adir/afile", b"blah", b"foo"])
 
     def test_add_default_paths_subdir(self):
         os.mkdir(os.path.join(self.repo.path, "foo"))
         with open(os.path.join(self.repo.path, "blah"), "w") as f:
             f.write("\n")
         with open(os.path.join(self.repo.path, "foo", "blie"), "w") as f:
             f.write("\n")
 
         cwd = os.getcwd()
         try:
             os.chdir(os.path.join(self.repo.path, "foo"))
             porcelain.add(repo=self.repo.path)
             porcelain.commit(
                 repo=self.repo.path,
                 message=b"test",
                 author=b"test <email>",
                 committer=b"test <email>",
             )
         finally:
             os.chdir(cwd)
 
         index = self.repo.open_index()
         self.assertEqual(sorted(index), [b"foo/blie"])
 
     def test_add_file(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=[fullpath])
         self.assertIn(b"foo", self.repo.open_index())
 
     def test_add_ignored(self):
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("foo\nsubdir/")
         with open(os.path.join(self.repo.path, "foo"), "w") as f:
             f.write("BAR")
         with open(os.path.join(self.repo.path, "bar"), "w") as f:
             f.write("BAR")
         os.mkdir(os.path.join(self.repo.path, "subdir"))
         with open(os.path.join(self.repo.path, "subdir", "baz"), "w") as f:
             f.write("BAZ")
         (added, ignored) = porcelain.add(
             self.repo.path,
             paths=[
                 os.path.join(self.repo.path, "foo"),
                 os.path.join(self.repo.path, "bar"),
                 os.path.join(self.repo.path, "subdir"),
             ],
         )
         self.assertIn(b"bar", self.repo.open_index())
         self.assertEqual(set(["bar"]), set(added))
         self.assertEqual(set(["foo", os.path.join("subdir", "")]), ignored)
 
     def test_add_file_absolute_path(self):
         # Absolute paths are (not yet) supported
         with open(os.path.join(self.repo.path, "foo"), "w") as f:
             f.write("BAR")
         porcelain.add(self.repo, paths=[os.path.join(self.repo.path, "foo")])
         self.assertIn(b"foo", self.repo.open_index())
 
     def test_add_not_in_repo(self):
         with open(os.path.join(self.test_dir, "foo"), "w") as f:
             f.write("BAR")
         self.assertRaises(
             ValueError,
             porcelain.add,
             self.repo,
             paths=[os.path.join(self.test_dir, "foo")],
         )
         self.assertRaises(
             (ValueError, FileNotFoundError),
             porcelain.add,
             self.repo,
             paths=["../foo"],
         )
         self.assertEqual([], list(self.repo.open_index()))
 
     def test_add_file_clrf_conversion(self):
         # Set the right configuration to the repo
         c = self.repo.get_config()
         c.set("core", "autocrlf", "input")
         c.write_to_path()
 
         # Add a file with CRLF line-ending
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "wb") as f:
             f.write(b"line1\r\nline2")
         porcelain.add(self.repo.path, paths=[fullpath])
 
         # The line-endings should have been converted to LF
         index = self.repo.open_index()
         self.assertIn(b"foo", index)
 
         entry = index[b"foo"]
         blob = self.repo[entry.sha]
         self.assertEqual(blob.data, b"line1\nline2")
 
 
 class RemoveTests(PorcelainTestCase):
     def test_remove_file(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=[fullpath])
         porcelain.commit(
             repo=self.repo,
             message=b"test",
             author=b"test <email>",
             committer=b"test <email>",
         )
         self.assertTrue(os.path.exists(os.path.join(self.repo.path, "foo")))
         cwd = os.getcwd()
         try:
             os.chdir(self.repo.path)
             porcelain.remove(self.repo.path, paths=["foo"])
         finally:
             os.chdir(cwd)
         self.assertFalse(os.path.exists(os.path.join(self.repo.path, "foo")))
 
     def test_remove_file_staged(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         cwd = os.getcwd()
         try:
             os.chdir(self.repo.path)
             porcelain.add(self.repo.path, paths=[fullpath])
             self.assertRaises(Exception, porcelain.rm, self.repo.path, paths=["foo"])
         finally:
             os.chdir(cwd)
 
     def test_remove_file_removed_on_disk(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=[fullpath])
         cwd = os.getcwd()
         try:
             os.chdir(self.repo.path)
             os.remove(fullpath)
             porcelain.remove(self.repo.path, paths=["foo"])
         finally:
             os.chdir(cwd)
         self.assertFalse(os.path.exists(os.path.join(self.repo.path, "foo")))
 
 
 class LogTests(PorcelainTestCase):
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.log(self.repo.path, outstream=outstream)
         self.assertEqual(3, outstream.getvalue().count("-" * 50))
 
     def test_max_entries(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.log(self.repo.path, outstream=outstream, max_entries=1)
         self.assertEqual(1, outstream.getvalue().count("-" * 50))
 
 
 class ShowTests(PorcelainTestCase):
     def test_nolist(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=c3.id, outstream=outstream)
         self.assertTrue(outstream.getvalue().startswith("-" * 50))
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=[c3.id], outstream=outstream)
         self.assertTrue(outstream.getvalue().startswith("-" * 50))
 
     def test_blob(self):
         b = Blob.from_string(b"The Foo\n")
         self.repo.object_store.add_object(b)
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=[b.id], outstream=outstream)
         self.assertEqual(outstream.getvalue(), "The Foo\n")
 
     def test_commit_no_parent(self):
         a = Blob.from_string(b"The Foo\n")
         ta = Tree()
         ta.add(b"somename", 0o100644, a.id)
         ca = make_commit(tree=ta.id)
         self.repo.object_store.add_objects([(a, None), (ta, None), (ca, None)])
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=[ca.id], outstream=outstream)
         self.assertMultiLineEqual(
             outstream.getvalue(),
             """\
 --------------------------------------------------
 commit: 344da06c1bb85901270b3e8875c988a027ec087d
 Author: Test Author <test@nodomain.com>
 Committer: Test Committer <test@nodomain.com>
 Date:   Fri Jan 01 2010 00:00:00 +0000
 
 Test message.
 
 diff --git a/somename b/somename
 new file mode 100644
 index 0000000..ea5c7bf
 --- /dev/null
 +++ b/somename
 @@ -0,0 +1 @@
 +The Foo
 """,
         )
 
     def test_tag(self):
         a = Blob.from_string(b"The Foo\n")
         ta = Tree()
         ta.add(b"somename", 0o100644, a.id)
         ca = make_commit(tree=ta.id)
         self.repo.object_store.add_objects([(a, None), (ta, None), (ca, None)])
         porcelain.tag_create(
             self.repo.path,
             b"tryme",
             b"foo <foo@bar.com>",
             b"bar",
             annotated=True,
             objectish=ca.id,
             tag_time=1552854211,
             tag_timezone=0,
         )
         outstream = StringIO()
         porcelain.show(self.repo, objects=[b"refs/tags/tryme"], outstream=outstream)
         self.maxDiff = None
         self.assertMultiLineEqual(
             outstream.getvalue(),
             """\
 Tagger: foo <foo@bar.com>
 Date:   Sun Mar 17 2019 20:23:31 +0000
 
 bar
 
 --------------------------------------------------
 commit: 344da06c1bb85901270b3e8875c988a027ec087d
 Author: Test Author <test@nodomain.com>
 Committer: Test Committer <test@nodomain.com>
 Date:   Fri Jan 01 2010 00:00:00 +0000
 
 Test message.
 
 diff --git a/somename b/somename
 new file mode 100644
 index 0000000..ea5c7bf
 --- /dev/null
 +++ b/somename
 @@ -0,0 +1 @@
 +The Foo
 """,
         )
 
     def test_commit_with_change(self):
         a = Blob.from_string(b"The Foo\n")
         ta = Tree()
         ta.add(b"somename", 0o100644, a.id)
         ca = make_commit(tree=ta.id)
         b = Blob.from_string(b"The Bar\n")
         tb = Tree()
         tb.add(b"somename", 0o100644, b.id)
         cb = make_commit(tree=tb.id, parents=[ca.id])
         self.repo.object_store.add_objects(
             [
                 (a, None),
                 (b, None),
                 (ta, None),
                 (tb, None),
                 (ca, None),
                 (cb, None),
             ]
         )
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=[cb.id], outstream=outstream)
         self.assertMultiLineEqual(
             outstream.getvalue(),
             """\
 --------------------------------------------------
 commit: 2c6b6c9cb72c130956657e1fdae58e5b103744fa
 Author: Test Author <test@nodomain.com>
 Committer: Test Committer <test@nodomain.com>
 Date:   Fri Jan 01 2010 00:00:00 +0000
 
 Test message.
 
 diff --git a/somename b/somename
 index ea5c7bf..fd38bcb 100644
 --- a/somename
 +++ b/somename
 @@ -1 +1 @@
 -The Foo
 +The Bar
 """,
         )
 
 
 class SymbolicRefTests(PorcelainTestCase):
     def test_set_wrong_symbolic_ref(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
 
         self.assertRaises(
             porcelain.Error, porcelain.symbolic_ref, self.repo.path, b"foobar"
         )
 
     def test_set_force_wrong_symbolic_ref(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.symbolic_ref(self.repo.path, b"force_foobar", force=True)
 
         # test if we actually changed the file
         with self.repo.get_named_file("HEAD") as f:
             new_ref = f.read()
         self.assertEqual(new_ref, b"ref: refs/heads/force_foobar\n")
 
     def test_set_symbolic_ref(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.symbolic_ref(self.repo.path, b"master")
 
     def test_set_symbolic_ref_other_than_master(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store,
             [[1], [2, 1], [3, 1, 2]],
             attrs=dict(refs="develop"),
         )
         self.repo.refs[b"HEAD"] = c3.id
         self.repo.refs[b"refs/heads/develop"] = c3.id
 
         porcelain.symbolic_ref(self.repo.path, b"develop")
 
         # test if we actually changed the file
         with self.repo.get_named_file("HEAD") as f:
             new_ref = f.read()
         self.assertEqual(new_ref, b"ref: refs/heads/develop\n")
 
 
 class DiffTreeTests(PorcelainTestCase):
     def test_empty(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         outstream = BytesIO()
         porcelain.diff_tree(self.repo.path, c2.tree, c3.tree, outstream=outstream)
         self.assertEqual(outstream.getvalue(), b"")
 
 
 class CommitTreeTests(PorcelainTestCase):
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         b = Blob()
         b.data = b"foo the bar"
         t = Tree()
         t.add(b"somename", 0o100644, b.id)
         self.repo.object_store.add_object(t)
         self.repo.object_store.add_object(b)
         sha = porcelain.commit_tree(
             self.repo.path,
             t.id,
             message=b"Withcommit.",
             author=b"Joe <joe@example.com>",
             committer=b"Jane <jane@example.com>",
         )
         self.assertTrue(isinstance(sha, bytes))
         self.assertEqual(len(sha), 40)
 
 
 class RevListTests(PorcelainTestCase):
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         outstream = BytesIO()
         porcelain.rev_list(self.repo.path, [c3.id], outstream=outstream)
         self.assertEqual(
             c3.id + b"\n" + c2.id + b"\n" + c1.id + b"\n", outstream.getvalue()
         )
 
 
 @skipIf(platform.python_implementation() == "PyPy" or sys.platform == "win32", "gpgme not easily available or supported on Windows and PyPy")
 class TagCreateSignTests(PorcelainGpgTestCase):
     def test_default_key(self):
         import gpg
 
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         cfg = self.repo.get_config()
         cfg.set(("user",), "signingKey", PorcelainGpgTestCase.DEFAULT_KEY_ID)
         self.import_default_key()
 
         porcelain.tag_create(
             self.repo.path,
             b"tryme",
             b"foo <foo@bar.com>",
             b"bar",
             annotated=True,
             sign=True,
         )
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b"refs/tags/tryme"]
         self.assertTrue(isinstance(tag, Tag))
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar\n", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
         tag = self.repo[b'refs/tags/tryme']
         # GPG Signatures aren't deterministic, so we can't do a static assertion.
         tag.verify()
         tag.verify(keyids=[PorcelainGpgTestCase.DEFAULT_KEY_ID])
 
         self.import_non_default_key()
         self.assertRaises(
             gpg.errors.MissingSignatures,
             tag.verify,
             keyids=[PorcelainGpgTestCase.NON_DEFAULT_KEY_ID],
         )
 
         tag._chunked_text = [b"bad data", tag._signature]
         self.assertRaises(
             gpg.errors.BadSignatures,
             tag.verify,
         )
 
     def test_non_default_key(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
         cfg = self.repo.get_config()
         cfg.set(("user",), "signingKey", PorcelainGpgTestCase.DEFAULT_KEY_ID)
         self.import_non_default_key()
 
         porcelain.tag_create(
             self.repo.path,
             b"tryme",
             b"foo <foo@bar.com>",
             b"bar",
             annotated=True,
             sign=PorcelainGpgTestCase.NON_DEFAULT_KEY_ID,
         )
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b"refs/tags/tryme"]
         self.assertTrue(isinstance(tag, Tag))
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar\n", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
         tag = self.repo[b'refs/tags/tryme']
         # GPG Signatures aren't deterministic, so we can't do a static assertion.
         tag.verify()
 
 
 class TagCreateTests(PorcelainTestCase):
     def test_annotated(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.tag_create(
             self.repo.path,
             b"tryme",
             b"foo <foo@bar.com>",
             b"bar",
             annotated=True,
         )
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b"refs/tags/tryme"]
         self.assertTrue(isinstance(tag, Tag))
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar\n", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
 
     def test_unannotated(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.tag_create(self.repo.path, b"tryme", annotated=False)
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         self.repo[b"refs/tags/tryme"]
         self.assertEqual(list(tags.values()), [self.repo.head()])
 
     def test_unannotated_unicode(self):
         c1, c2, c3 = build_commit_graph(
             self.repo.object_store, [[1], [2, 1], [3, 1, 2]]
         )
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.tag_create(self.repo.path, "tryme", annotated=False)
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         self.repo[b"refs/tags/tryme"]
         self.assertEqual(list(tags.values()), [self.repo.head()])
 
 
 class TagListTests(PorcelainTestCase):
     def test_empty(self):
         tags = porcelain.tag_list(self.repo.path)
         self.assertEqual([], tags)
 
     def test_simple(self):
         self.repo.refs[b"refs/tags/foo"] = b"aa" * 20
         self.repo.refs[b"refs/tags/bar/bla"] = b"bb" * 20
         tags = porcelain.tag_list(self.repo.path)
 
         self.assertEqual([b"bar/bla", b"foo"], tags)
 
 
 class TagDeleteTests(PorcelainTestCase):
     def test_simple(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.tag_create(self.repo, b"foo")
         self.assertTrue(b"foo" in porcelain.tag_list(self.repo))
         porcelain.tag_delete(self.repo, b"foo")
         self.assertFalse(b"foo" in porcelain.tag_list(self.repo))
 
 
 class ResetTests(PorcelainTestCase):
     def test_hard_head(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=[fullpath])
         porcelain.commit(
             self.repo.path,
             message=b"Some message",
             committer=b"Jane <jane@example.com>",
             author=b"John <john@example.com>",
         )
 
         with open(os.path.join(self.repo.path, "foo"), "wb") as f:
             f.write(b"OOH")
 
         porcelain.reset(self.repo, "hard", b"HEAD")
 
         index = self.repo.open_index()
         changes = list(
             tree_changes(
                 self.repo,
                 index.commit(self.repo.object_store),
                 self.repo[b"HEAD"].tree,
             )
         )
 
         self.assertEqual([], changes)
 
     def test_hard_commit(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=[fullpath])
         sha = porcelain.commit(
             self.repo.path,
             message=b"Some message",
             committer=b"Jane <jane@example.com>",
             author=b"John <john@example.com>",
         )
 
         with open(fullpath, "wb") as f:
             f.write(b"BAZ")
         porcelain.add(self.repo.path, paths=[fullpath])
         porcelain.commit(
             self.repo.path,
             message=b"Some other message",
             committer=b"Jane <jane@example.com>",
             author=b"John <john@example.com>",
         )
 
         porcelain.reset(self.repo, "hard", sha)
 
         index = self.repo.open_index()
         changes = list(
             tree_changes(
                 self.repo,
                 index.commit(self.repo.object_store),
                 self.repo[sha].tree,
             )
         )
 
         self.assertEqual([], changes)
 
 
 class PushTests(PorcelainTestCase):
     def test_simple(self):
         """
         Basic test of porcelain push where self.repo is the remote.  First
         clone the remote, commit a file to the clone, then push the changes
         back to the remote.
         """
         outstream = BytesIO()
         errstream = BytesIO()
 
         porcelain.commit(
             repo=self.repo.path,
             message=b"init",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.clone(
             self.repo.path, target=clone_path, errstream=errstream
         )
         try:
             self.assertEqual(target_repo[b"HEAD"], self.repo[b"HEAD"])
         finally:
             target_repo.close()
 
         # create a second file to be pushed back to origin
         handle, fullpath = tempfile.mkstemp(dir=clone_path)
         os.close(handle)
         porcelain.add(repo=clone_path, paths=[fullpath])
         porcelain.commit(
             repo=clone_path,
             message=b"push",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Setup a non-checked out branch in the remote
         refs_path = b"refs/heads/foo"
         new_id = self.repo[b"HEAD"].id
         self.assertNotEqual(new_id, ZERO_SHA)
         self.repo.refs[refs_path] = new_id
 
         # Push to the remote
         porcelain.push(
             clone_path,
             "origin",
             b"HEAD:" + refs_path,
             outstream=outstream,
             errstream=errstream,
         )
 
         self.assertEqual(
             target_repo.refs[b"refs/remotes/origin/foo"],
             target_repo.refs[b"HEAD"],
         )
 
         # Check that the target and source
         with Repo(clone_path) as r_clone:
             self.assertEqual(
                 {
                     b"HEAD": new_id,
                     b"refs/heads/foo": r_clone[b"HEAD"].id,
                     b"refs/heads/master": new_id,
                 },
                 self.repo.get_refs(),
             )
             self.assertEqual(r_clone[b"HEAD"].id, self.repo[refs_path].id)
 
             # Get the change in the target repo corresponding to the add
             # this will be in the foo branch.
             change = list(
                 tree_changes(
                     self.repo,
                     self.repo[b"HEAD"].tree,
                     self.repo[b"refs/heads/foo"].tree,
                 )
             )[0]
             self.assertEqual(
                 os.path.basename(fullpath), change.new.path.decode("ascii")
             )
 
     def test_local_missing(self):
         """Pushing a new branch."""
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.init(clone_path)
         target_repo.close()
 
         self.assertRaises(
             porcelain.Error,
             porcelain.push,
             self.repo,
             clone_path,
             b"HEAD:refs/heads/master",
             outstream=outstream,
             errstream=errstream,
         )
 
     def test_new(self):
         """Pushing a new branch."""
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.init(clone_path)
         target_repo.close()
 
         # create a second file to be pushed back to origin
         handle, fullpath = tempfile.mkstemp(dir=clone_path)
         os.close(handle)
         porcelain.add(repo=clone_path, paths=[fullpath])
         new_id = porcelain.commit(
             repo=self.repo,
             message=b"push",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Push to the remote
         porcelain.push(
             self.repo,
             clone_path,
             b"HEAD:refs/heads/master",
             outstream=outstream,
             errstream=errstream,
         )
 
         with Repo(clone_path) as r_clone:
             self.assertEqual(
                 {
                     b"HEAD": new_id,
                     b"refs/heads/master": new_id,
                 },
                 r_clone.get_refs(),
             )
 
     def test_delete(self):
         """Basic test of porcelain push, removing a branch."""
         outstream = BytesIO()
         errstream = BytesIO()
 
         porcelain.commit(
             repo=self.repo.path,
             message=b"init",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.clone(
             self.repo.path, target=clone_path, errstream=errstream
         )
         target_repo.close()
 
         # Setup a non-checked out branch in the remote
         refs_path = b"refs/heads/foo"
         new_id = self.repo[b"HEAD"].id
         self.assertNotEqual(new_id, ZERO_SHA)
         self.repo.refs[refs_path] = new_id
 
         # Push to the remote
         porcelain.push(
             clone_path,
             self.repo.path,
             b":" + refs_path,
             outstream=outstream,
             errstream=errstream,
         )
 
         self.assertEqual(
             {
                 b"HEAD": new_id,
                 b"refs/heads/master": new_id,
             },
             self.repo.get_refs(),
         )
 
     def test_diverged(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         porcelain.commit(
             repo=self.repo.path,
             message=b"init",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.clone(
             self.repo.path, target=clone_path, errstream=errstream
         )
         target_repo.close()
 
         remote_id = porcelain.commit(
             repo=self.repo.path,
             message=b"remote change",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         local_id = porcelain.commit(
             repo=clone_path,
             message=b"local change",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Push to the remote
         self.assertRaises(
             porcelain.DivergedBranches,
             porcelain.push,
             clone_path,
             self.repo.path,
             b"refs/heads/master",
             outstream=outstream,
             errstream=errstream,
         )
 
         self.assertEqual(
             {
                 b"HEAD": remote_id,
                 b"refs/heads/master": remote_id,
             },
             self.repo.get_refs(),
         )
 
         self.assertEqual(b"", outstream.getvalue())
         self.assertEqual(b"", errstream.getvalue())
 
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Push to the remote with --force
         porcelain.push(
             clone_path,
             self.repo.path,
             b"refs/heads/master",
             outstream=outstream,
             errstream=errstream,
             force=True,
         )
 
         self.assertEqual(
             {
                 b"HEAD": local_id,
                 b"refs/heads/master": local_id,
             },
             self.repo.get_refs(),
         )
 
         self.assertEqual(b"", outstream.getvalue())
         self.assertTrue(re.match(b"Push to .* successful.\n", errstream.getvalue()))
 
 
 class PullTests(PorcelainTestCase):
     def setUp(self):
         super(PullTests, self).setUp()
         # create a file for initial commit
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test",
             author=b"test <email>",
             committer=b"test <email>",
         )
 
         # Setup target repo
         self.target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, self.target_path)
         target_repo = porcelain.clone(
             self.repo.path, target=self.target_path, errstream=BytesIO()
         )
         target_repo.close()
 
         # create a second file to be pushed
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test2",
             author=b"test2 <email>",
             committer=b"test2 <email>",
         )
 
         self.assertIn(b"refs/heads/master", self.repo.refs)
         self.assertIn(b"refs/heads/master", target_repo.refs)
 
     def test_simple(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Pull changes into the cloned repo
         porcelain.pull(
             self.target_path,
             self.repo.path,
             b"refs/heads/master",
             outstream=outstream,
             errstream=errstream,
         )
 
         # Check the target repo for pushed changes
         with Repo(self.target_path) as r:
             self.assertEqual(r[b"HEAD"].id, self.repo[b"HEAD"].id)
 
     def test_diverged(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         c3a = porcelain.commit(
             repo=self.target_path,
             message=b"test3a",
             author=b"test2 <email>",
             committer=b"test2 <email>",
         )
 
         porcelain.commit(
             repo=self.repo.path,
             message=b"test3b",
             author=b"test2 <email>",
             committer=b"test2 <email>",
         )
 
         # Pull changes into the cloned repo
         self.assertRaises(
             porcelain.DivergedBranches,
             porcelain.pull,
             self.target_path,
             self.repo.path,
             b"refs/heads/master",
             outstream=outstream,
             errstream=errstream,
         )
 
         # Check the target repo for pushed changes
         with Repo(self.target_path) as r:
             self.assertEqual(r[b"refs/heads/master"].id, c3a)
 
         self.assertRaises(
             NotImplementedError,
             porcelain.pull,
             self.target_path,
             self.repo.path,
             b"refs/heads/master",
             outstream=outstream,
             errstream=errstream,
             fast_forward=False,
         )
 
         # Check the target repo for pushed changes
         with Repo(self.target_path) as r:
             self.assertEqual(r[b"refs/heads/master"].id, c3a)
 
     def test_no_refspec(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Pull changes into the cloned repo
         porcelain.pull(
             self.target_path,
             self.repo.path,
             outstream=outstream,
             errstream=errstream,
         )
 
         # Check the target repo for pushed changes
         with Repo(self.target_path) as r:
             self.assertEqual(r[b"HEAD"].id, self.repo[b"HEAD"].id)
 
     def test_no_remote_location(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Pull changes into the cloned repo
         porcelain.pull(
             self.target_path,
             refspecs=b"refs/heads/master",
             outstream=outstream,
             errstream=errstream,
         )
 
         # Check the target repo for pushed changes
         with Repo(self.target_path) as r:
             self.assertEqual(r[b"HEAD"].id, self.repo[b"HEAD"].id)
 
 
 class StatusTests(PorcelainTestCase):
     def test_empty(self):
         results = porcelain.status(self.repo)
         self.assertEqual({"add": [], "delete": [], "modify": []}, results.staged)
         self.assertEqual([], results.unstaged)
 
     def test_status_base(self):
         """Integration test for `status` functionality."""
 
         # Commit a dummy file then modify it
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("origstuff")
 
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # modify access and modify time of path
         os.utime(fullpath, (0, 0))
 
         with open(fullpath, "wb") as f:
             f.write(b"stuff")
 
         # Make a dummy file and stage it
         filename_add = "bar"
         fullpath = os.path.join(self.repo.path, filename_add)
         with open(fullpath, "w") as f:
             f.write("stuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
 
         results = porcelain.status(self.repo)
 
         self.assertEqual(results.staged["add"][0], filename_add.encode("ascii"))
         self.assertEqual(results.unstaged, [b"foo"])
 
     def test_status_all(self):
         del_path = os.path.join(self.repo.path, "foo")
         mod_path = os.path.join(self.repo.path, "bar")
         add_path = os.path.join(self.repo.path, "baz")
         us_path = os.path.join(self.repo.path, "blye")
         ut_path = os.path.join(self.repo.path, "blyat")
         with open(del_path, "w") as f:
             f.write("origstuff")
         with open(mod_path, "w") as f:
             f.write("origstuff")
         with open(us_path, "w") as f:
             f.write("origstuff")
         porcelain.add(repo=self.repo.path, paths=[del_path, mod_path, us_path])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
         porcelain.remove(self.repo.path, [del_path])
         with open(add_path, "w") as f:
             f.write("origstuff")
         with open(mod_path, "w") as f:
             f.write("more_origstuff")
         with open(us_path, "w") as f:
             f.write("more_origstuff")
         porcelain.add(repo=self.repo.path, paths=[add_path, mod_path])
         with open(us_path, "w") as f:
             f.write("\norigstuff")
         with open(ut_path, "w") as f:
             f.write("origstuff")
         results = porcelain.status(self.repo.path)
         self.assertDictEqual(
             {"add": [b"baz"], "delete": [b"foo"], "modify": [b"bar"]},
             results.staged,
         )
         self.assertListEqual(results.unstaged, [b"blye"])
         self.assertListEqual(results.untracked, ["blyat"])
 
     def test_status_crlf_mismatch(self):
         # First make a commit as if the file has been added on a Linux system
         # or with core.autocrlf=True
         file_path = os.path.join(self.repo.path, "crlf")
         with open(file_path, "wb") as f:
             f.write(b"line1\nline2")
         porcelain.add(repo=self.repo.path, paths=[file_path])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Then update the file as if it was created by CGit on a Windows
         # system with core.autocrlf=true
         with open(file_path, "wb") as f:
             f.write(b"line1\r\nline2")
 
         results = porcelain.status(self.repo)
         self.assertDictEqual({"add": [], "delete": [], "modify": []}, results.staged)
         self.assertListEqual(results.unstaged, [b"crlf"])
         self.assertListEqual(results.untracked, [])
 
     def test_status_autocrlf_true(self):
         # First make a commit as if the file has been added on a Linux system
         # or with core.autocrlf=True
         file_path = os.path.join(self.repo.path, "crlf")
         with open(file_path, "wb") as f:
             f.write(b"line1\nline2")
         porcelain.add(repo=self.repo.path, paths=[file_path])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         # Then update the file as if it was created by CGit on a Windows
         # system with core.autocrlf=true
         with open(file_path, "wb") as f:
             f.write(b"line1\r\nline2")
 
         # TODO: It should be set automatically by looking at the configuration
         c = self.repo.get_config()
         c.set("core", "autocrlf", True)
         c.write_to_path()
 
         results = porcelain.status(self.repo)
         self.assertDictEqual({"add": [], "delete": [], "modify": []}, results.staged)
         self.assertListEqual(results.unstaged, [])
         self.assertListEqual(results.untracked, [])
 
     def test_status_autocrlf_input(self):
         # Commit existing file with CRLF
         file_path = os.path.join(self.repo.path, "crlf-exists")
         with open(file_path, "wb") as f:
             f.write(b"line1\r\nline2")
         porcelain.add(repo=self.repo.path, paths=[file_path])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         c = self.repo.get_config()
         c.set("core", "autocrlf", "input")
         c.write_to_path()
 
         # Add new (untracked) file
         file_path = os.path.join(self.repo.path, "crlf-new")
         with open(file_path, "wb") as f:
             f.write(b"line1\r\nline2")
         porcelain.add(repo=self.repo.path, paths=[file_path])
 
         results = porcelain.status(self.repo)
         self.assertDictEqual({"add": [b"crlf-new"], "delete": [], "modify": []}, results.staged)
         self.assertListEqual(results.unstaged, [])
         self.assertListEqual(results.untracked, [])
 
     def test_get_tree_changes_add(self):
         """Unit test for get_tree_changes add."""
 
         # Make a dummy file, stage
         filename = "bar"
         fullpath = os.path.join(self.repo.path, filename)
         with open(fullpath, "w") as f:
             f.write("stuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         filename = "foo"
         fullpath = os.path.join(self.repo.path, filename)
         with open(fullpath, "w") as f:
             f.write("stuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
         changes = porcelain.get_tree_changes(self.repo.path)
 
         self.assertEqual(changes["add"][0], filename.encode("ascii"))
         self.assertEqual(len(changes["add"]), 1)
         self.assertEqual(len(changes["modify"]), 0)
         self.assertEqual(len(changes["delete"]), 0)
 
     def test_get_tree_changes_modify(self):
         """Unit test for get_tree_changes modify."""
 
         # Make a dummy file, stage, commit, modify
         filename = "foo"
         fullpath = os.path.join(self.repo.path, filename)
         with open(fullpath, "w") as f:
             f.write("stuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
         with open(fullpath, "w") as f:
             f.write("otherstuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
         changes = porcelain.get_tree_changes(self.repo.path)
 
         self.assertEqual(changes["modify"][0], filename.encode("ascii"))
         self.assertEqual(len(changes["add"]), 0)
         self.assertEqual(len(changes["modify"]), 1)
         self.assertEqual(len(changes["delete"]), 0)
 
     def test_get_tree_changes_delete(self):
         """Unit test for get_tree_changes delete."""
 
         # Make a dummy file, stage, commit, remove
         filename = "foo"
         fullpath = os.path.join(self.repo.path, filename)
         with open(fullpath, "w") as f:
             f.write("stuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
         cwd = os.getcwd()
         try:
             os.chdir(self.repo.path)
             porcelain.remove(repo=self.repo.path, paths=[filename])
         finally:
             os.chdir(cwd)
         changes = porcelain.get_tree_changes(self.repo.path)
 
         self.assertEqual(changes["delete"][0], filename.encode("ascii"))
         self.assertEqual(len(changes["add"]), 0)
         self.assertEqual(len(changes["modify"]), 0)
         self.assertEqual(len(changes["delete"]), 1)
 
     def test_get_untracked_paths(self):
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("ignored\n")
         with open(os.path.join(self.repo.path, "ignored"), "w") as f:
             f.write("blah\n")
         with open(os.path.join(self.repo.path, "notignored"), "w") as f:
             f.write("blah\n")
         os.symlink(
             os.path.join(self.repo.path, os.pardir, "external_target"),
             os.path.join(self.repo.path, "link"),
         )
         self.assertEqual(
             set(["ignored", "notignored", ".gitignore", "link"]),
             set(
                 porcelain.get_untracked_paths(
                     self.repo.path, self.repo.path, self.repo.open_index()
                 )
             ),
         )
         self.assertEqual(
             set([".gitignore", "notignored", "link"]),
             set(porcelain.status(self.repo).untracked),
         )
         self.assertEqual(
             set([".gitignore", "notignored", "ignored", "link"]),
             set(porcelain.status(self.repo, ignored=True).untracked),
         )
 
     def test_get_untracked_paths_subrepo(self):
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("nested/\n")
         with open(os.path.join(self.repo.path, "notignored"), "w") as f:
             f.write("blah\n")
 
         subrepo = Repo.init(os.path.join(self.repo.path, "nested"), mkdir=True)
         with open(os.path.join(subrepo.path, "ignored"), "w") as f:
             f.write("bleep\n")
         with open(os.path.join(subrepo.path, "with"), "w") as f:
             f.write("bloop\n")
         with open(os.path.join(subrepo.path, "manager"), "w") as f:
             f.write("blop\n")
 
         self.assertEqual(
             set([".gitignore", "notignored", os.path.join("nested", "")]),
             set(
                 porcelain.get_untracked_paths(
                     self.repo.path, self.repo.path, self.repo.open_index()
                 )
             ),
         )
         self.assertEqual(
             set([".gitignore", "notignored"]),
             set(
                 porcelain.get_untracked_paths(
                     self.repo.path,
                     self.repo.path,
                     self.repo.open_index(),
                     exclude_ignored=True,
                 )
             ),
         )
         self.assertEqual(
             set(["ignored", "with", "manager"]),
             set(
                 porcelain.get_untracked_paths(
                     subrepo.path, subrepo.path, subrepo.open_index()
                 )
             ),
         )
         self.assertEqual(
             set(),
             set(
                 porcelain.get_untracked_paths(
                     subrepo.path,
                     self.repo.path,
                     self.repo.open_index(),
                 )
             ),
         )
         self.assertEqual(
             set([os.path.join('nested', 'ignored'),
                 os.path.join('nested', 'with'),
                 os.path.join('nested', 'manager')]),
             set(
                 porcelain.get_untracked_paths(
                     self.repo.path,
                     subrepo.path,
                     self.repo.open_index(),
                 )
             ),
         )
 
     def test_get_untracked_paths_subdir(self):
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("subdir/\nignored")
         with open(os.path.join(self.repo.path, "notignored"), "w") as f:
             f.write("blah\n")
         os.mkdir(os.path.join(self.repo.path, "subdir"))
         with open(os.path.join(self.repo.path, "ignored"), "w") as f:
             f.write("foo")
         with open(os.path.join(self.repo.path, "subdir", "ignored"), "w") as f:
             f.write("foo")
 
         self.assertEqual(
             set(
                 [
                     ".gitignore",
                     "notignored",
                     "ignored",
                     os.path.join("subdir", ""),
                 ]
             ),
             set(
                 porcelain.get_untracked_paths(
                     self.repo.path,
                     self.repo.path,
                     self.repo.open_index(),
                 )
             )
         )
         self.assertEqual(
             set([".gitignore", "notignored"]),
             set(
                 porcelain.get_untracked_paths(
                     self.repo.path,
                     self.repo.path,
                     self.repo.open_index(),
                     exclude_ignored=True,
                 )
             )
         )
 
 
 # TODO(jelmer): Add test for dulwich.porcelain.daemon
 
 
 class UploadPackTests(PorcelainTestCase):
     """Tests for upload_pack."""
 
     def test_upload_pack(self):
         outf = BytesIO()
         exitcode = porcelain.upload_pack(self.repo.path, BytesIO(b"0000"), outf)
         outlines = outf.getvalue().splitlines()
         self.assertEqual([b"0000"], outlines)
         self.assertEqual(0, exitcode)
 
 
 class ReceivePackTests(PorcelainTestCase):
     """Tests for receive_pack."""
 
     def test_receive_pack(self):
         filename = "foo"
         fullpath = os.path.join(self.repo.path, filename)
         with open(fullpath, "w") as f:
             f.write("stuff")
         porcelain.add(repo=self.repo.path, paths=fullpath)
         self.repo.do_commit(
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
             author_timestamp=1402354300,
             commit_timestamp=1402354300,
             author_timezone=0,
             commit_timezone=0,
         )
         outf = BytesIO()
         exitcode = porcelain.receive_pack(self.repo.path, BytesIO(b"0000"), outf)
         outlines = outf.getvalue().splitlines()
         self.assertEqual(
             [
                 b"0091319b56ce3aee2d489f759736a79cc552c9bb86d9 HEAD\x00 report-status "  # noqa: E501
                 b"delete-refs quiet ofs-delta side-band-64k "
                 b"no-done symref=HEAD:refs/heads/master",
                 b"003f319b56ce3aee2d489f759736a79cc552c9bb86d9 refs/heads/master",
                 b"0000",
             ],
             outlines,
         )
         self.assertEqual(0, exitcode)
 
 
 class BranchListTests(PorcelainTestCase):
     def test_standard(self):
         self.assertEqual(set([]), set(porcelain.branch_list(self.repo)))
 
     def test_new_branch(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertEqual(
             set([b"master", b"foo"]), set(porcelain.branch_list(self.repo))
         )
 
 
 class BranchCreateTests(PorcelainTestCase):
     def test_branch_exists(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertRaises(porcelain.Error, porcelain.branch_create, self.repo, b"foo")
         porcelain.branch_create(self.repo, b"foo", force=True)
 
     def test_new_branch(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertEqual(
             set([b"master", b"foo"]), set(porcelain.branch_list(self.repo))
         )
 
 
 class BranchDeleteTests(PorcelainTestCase):
     def test_simple(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
         porcelain.branch_delete(self.repo, b"foo")
         self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
 
     def test_simple_unicode(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, "foo")
         self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
         porcelain.branch_delete(self.repo, "foo")
         self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
 
 
 class FetchTests(PorcelainTestCase):
     def test_simple(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # create a file for initial commit
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test",
             author=b"test <email>",
             committer=b"test <email>",
         )
 
         # Setup target repo
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
         target_repo = porcelain.clone(
             self.repo.path, target=target_path, errstream=errstream
         )
 
         # create a second file to be pushed
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test2",
             author=b"test2 <email>",
             committer=b"test2 <email>",
         )
 
         self.assertFalse(self.repo[b"HEAD"].id in target_repo)
         target_repo.close()
 
         # Fetch changes into the cloned repo
         porcelain.fetch(target_path, "origin", outstream=outstream, errstream=errstream)
 
         # Assert that fetch updated the local image of the remote
         self.assert_correct_remote_refs(target_repo.get_refs(), self.repo.get_refs())
 
         # Check the target repo for pushed changes
         with Repo(target_path) as r:
             self.assertTrue(self.repo[b"HEAD"].id in r)
 
     def test_with_remote_name(self):
         remote_name = "origin"
         outstream = BytesIO()
         errstream = BytesIO()
 
         # create a file for initial commit
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test",
             author=b"test <email>",
             committer=b"test <email>",
         )
 
         # Setup target repo
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
         target_repo = porcelain.clone(
             self.repo.path, target=target_path, errstream=errstream
         )
 
         # Capture current refs
         target_refs = target_repo.get_refs()
 
         # create a second file to be pushed
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.commit(
             repo=self.repo.path,
             message=b"test2",
             author=b"test2 <email>",
             committer=b"test2 <email>",
         )
 
         self.assertFalse(self.repo[b"HEAD"].id in target_repo)
 
         target_config = target_repo.get_config()
         target_config.set(
             (b"remote", remote_name.encode()), b"url", self.repo.path.encode()
         )
         target_repo.close()
 
         # Fetch changes into the cloned repo
         porcelain.fetch(
             target_path, remote_name, outstream=outstream, errstream=errstream
         )
 
         # Assert that fetch updated the local image of the remote
         self.assert_correct_remote_refs(target_repo.get_refs(), self.repo.get_refs())
 
         # Check the target repo for pushed changes, as well as updates
         # for the refs
         with Repo(target_path) as r:
             self.assertTrue(self.repo[b"HEAD"].id in r)
             self.assertNotEqual(self.repo.get_refs(), target_refs)
 
     def assert_correct_remote_refs(
         self, local_refs, remote_refs, remote_name=b"origin"
     ):
         """Assert that known remote refs corresponds to actual remote refs."""
         local_ref_prefix = b"refs/heads"
         remote_ref_prefix = b"refs/remotes/" + remote_name
 
         locally_known_remote_refs = {
             k[len(remote_ref_prefix) + 1 :]: v
             for k, v in local_refs.items()
             if k.startswith(remote_ref_prefix)
         }
 
         normalized_remote_refs = {
             k[len(local_ref_prefix) + 1 :]: v
             for k, v in remote_refs.items()
             if k.startswith(local_ref_prefix)
         }
 
         self.assertEqual(locally_known_remote_refs, normalized_remote_refs)
 
 
 class RepackTests(PorcelainTestCase):
     def test_empty(self):
         porcelain.repack(self.repo)
 
     def test_simple(self):
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         porcelain.add(repo=self.repo.path, paths=fullpath)
         porcelain.repack(self.repo)
 
 
 class LsTreeTests(PorcelainTestCase):
     def test_empty(self):
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         f = StringIO()
         porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
         self.assertEqual(f.getvalue(), "")
 
     def test_simple(self):
         # Commit a dummy file then modify it
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("origstuff")
 
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         f = StringIO()
         porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
         self.assertEqual(
             f.getvalue(),
             "100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n",
         )
 
     def test_recursive(self):
         # Create a directory then write a dummy file in it
         dirpath = os.path.join(self.repo.path, "adir")
         filepath = os.path.join(dirpath, "afile")
         os.mkdir(dirpath)
         with open(filepath, "w") as f:
             f.write("origstuff")
         porcelain.add(repo=self.repo.path, paths=[filepath])
         porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
         f = StringIO()
         porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
         self.assertEqual(
             f.getvalue(),
             "40000 tree b145cc69a5e17693e24d8a7be0016ed8075de66d\tadir\n",
         )
         f = StringIO()
         porcelain.ls_tree(self.repo, b"HEAD", outstream=f, recursive=True)
         self.assertEqual(
             f.getvalue(),
             "40000 tree b145cc69a5e17693e24d8a7be0016ed8075de66d\tadir\n"
             "100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tadir"
             "/afile\n",
         )
 
 
 class LsRemoteTests(PorcelainTestCase):
     def test_empty(self):
         self.assertEqual({}, porcelain.ls_remote(self.repo.path))
 
     def test_some(self):
         cid = porcelain.commit(
             repo=self.repo.path,
             message=b"test status",
             author=b"author <email>",
             committer=b"committer <email>",
         )
 
         self.assertEqual(
             {b"refs/heads/master": cid, b"HEAD": cid},
             porcelain.ls_remote(self.repo.path),
         )
 
 
 class LsFilesTests(PorcelainTestCase):
     def test_empty(self):
         self.assertEqual([], list(porcelain.ls_files(self.repo)))
 
     def test_simple(self):
         # Commit a dummy file then modify it
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("origstuff")
 
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         self.assertEqual([b"foo"], list(porcelain.ls_files(self.repo)))
 
 
 class RemoteAddTests(PorcelainTestCase):
     def test_new(self):
         porcelain.remote_add(self.repo, "jelmer", "git://jelmer.uk/code/dulwich")
         c = self.repo.get_config()
         self.assertEqual(
             c.get((b"remote", b"jelmer"), b"url"),
             b"git://jelmer.uk/code/dulwich",
         )
 
     def test_exists(self):
         porcelain.remote_add(self.repo, "jelmer", "git://jelmer.uk/code/dulwich")
         self.assertRaises(
             porcelain.RemoteExists,
             porcelain.remote_add,
             self.repo,
             "jelmer",
             "git://jelmer.uk/code/dulwich",
         )
 
 
 class CheckIgnoreTests(PorcelainTestCase):
     def test_check_ignored(self):
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("foo")
         foo_path = os.path.join(self.repo.path, "foo")
         with open(foo_path, "w") as f:
             f.write("BAR")
         bar_path = os.path.join(self.repo.path, "bar")
         with open(bar_path, "w") as f:
             f.write("BAR")
         self.assertEqual(["foo"], list(porcelain.check_ignore(self.repo, [foo_path])))
         self.assertEqual([], list(porcelain.check_ignore(self.repo, [bar_path])))
 
     def test_check_added_abs(self):
         path = os.path.join(self.repo.path, "foo")
         with open(path, "w") as f:
             f.write("BAR")
         self.repo.stage(["foo"])
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("foo\n")
         self.assertEqual([], list(porcelain.check_ignore(self.repo, [path])))
         self.assertEqual(
             ["foo"],
             list(porcelain.check_ignore(self.repo, [path], no_index=True)),
         )
 
     def test_check_added_rel(self):
         with open(os.path.join(self.repo.path, "foo"), "w") as f:
             f.write("BAR")
         self.repo.stage(["foo"])
         with open(os.path.join(self.repo.path, ".gitignore"), "w") as f:
             f.write("foo\n")
         cwd = os.getcwd()
         os.mkdir(os.path.join(self.repo.path, "bar"))
         os.chdir(os.path.join(self.repo.path, "bar"))
         try:
             self.assertEqual(list(porcelain.check_ignore(self.repo, ["../foo"])), [])
             self.assertEqual(
                 ["../foo"],
                 list(porcelain.check_ignore(self.repo, ["../foo"], no_index=True)),
             )
         finally:
             os.chdir(cwd)
 
 
 class UpdateHeadTests(PorcelainTestCase):
     def test_set_to_branch(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo.refs[b"refs/heads/blah"] = c1.id
         porcelain.update_head(self.repo, "blah")
         self.assertEqual(c1.id, self.repo.head())
         self.assertEqual(b"ref: refs/heads/blah", self.repo.refs.read_ref(b"HEAD"))
 
     def test_set_to_branch_detached(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo.refs[b"refs/heads/blah"] = c1.id
         porcelain.update_head(self.repo, "blah", detached=True)
         self.assertEqual(c1.id, self.repo.head())
         self.assertEqual(c1.id, self.repo.refs.read_ref(b"HEAD"))
 
     def test_set_to_commit_detached(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo.refs[b"refs/heads/blah"] = c1.id
         porcelain.update_head(self.repo, c1.id, detached=True)
         self.assertEqual(c1.id, self.repo.head())
         self.assertEqual(c1.id, self.repo.refs.read_ref(b"HEAD"))
 
     def test_set_new_branch(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo.refs[b"refs/heads/blah"] = c1.id
         porcelain.update_head(self.repo, "blah", new_branch="bar")
         self.assertEqual(c1.id, self.repo.head())
         self.assertEqual(b"ref: refs/heads/bar", self.repo.refs.read_ref(b"HEAD"))
 
 
 class MailmapTests(PorcelainTestCase):
     def test_no_mailmap(self):
         self.assertEqual(
             b"Jelmer Vernooij <jelmer@samba.org>",
             porcelain.check_mailmap(self.repo, b"Jelmer Vernooij <jelmer@samba.org>"),
         )
 
     def test_mailmap_lookup(self):
         with open(os.path.join(self.repo.path, ".mailmap"), "wb") as f:
             f.write(
                 b"""\
 Jelmer Vernooij <jelmer@debian.org>
 """
             )
         self.assertEqual(
             b"Jelmer Vernooij <jelmer@debian.org>",
             porcelain.check_mailmap(self.repo, b"Jelmer Vernooij <jelmer@samba.org>"),
         )
 
 
 class FsckTests(PorcelainTestCase):
     def test_none(self):
         self.assertEqual([], list(porcelain.fsck(self.repo)))
 
     def test_git_dir(self):
         obj = Tree()
         a = Blob()
         a.data = b"foo"
         obj.add(b".git", 0o100644, a.id)
         self.repo.object_store.add_objects([(a, None), (obj, None)])
         self.assertEqual(
             [(obj.id, "invalid name .git")],
             [(sha, str(e)) for (sha, e) in porcelain.fsck(self.repo)],
         )
 
 
 class DescribeTests(PorcelainTestCase):
     def test_no_commits(self):
         self.assertRaises(KeyError, porcelain.describe, self.repo.path)
 
     def test_single_commit(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         sha = porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
         self.assertEqual(
             "g{}".format(sha[:7].decode("ascii")),
             porcelain.describe(self.repo.path),
         )
 
     def test_tag(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
         porcelain.tag_create(
             self.repo.path,
             b"tryme",
             b"foo <foo@bar.com>",
             b"bar",
             annotated=True,
         )
         self.assertEqual("tryme", porcelain.describe(self.repo.path))
 
     def test_tag_and_commit(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
         porcelain.tag_create(
             self.repo.path,
             b"tryme",
             b"foo <foo@bar.com>",
             b"bar",
             annotated=True,
         )
         with open(fullpath, "w") as f:
             f.write("BAR2")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         sha = porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
         self.assertEqual(
             "tryme-1-g{}".format(sha[:7].decode("ascii")),
             porcelain.describe(self.repo.path),
         )
 
 
 class PathToTreeTests(PorcelainTestCase):
     def setUp(self):
         super(PathToTreeTests, self).setUp()
         self.fp = os.path.join(self.test_dir, "bar")
         with open(self.fp, "w") as f:
             f.write("something")
         oldcwd = os.getcwd()
         self.addCleanup(os.chdir, oldcwd)
         os.chdir(self.test_dir)
 
     def test_path_to_tree_path_base(self):
         self.assertEqual(b"bar", porcelain.path_to_tree_path(self.test_dir, self.fp))
         self.assertEqual(b"bar", porcelain.path_to_tree_path(".", "./bar"))
         self.assertEqual(b"bar", porcelain.path_to_tree_path(".", "bar"))
         cwd = os.getcwd()
         self.assertEqual(
             b"bar", porcelain.path_to_tree_path(".", os.path.join(cwd, "bar"))
         )
         self.assertEqual(b"bar", porcelain.path_to_tree_path(cwd, "bar"))
 
     def test_path_to_tree_path_syntax(self):
         self.assertEqual(b"bar", porcelain.path_to_tree_path(".", "./bar"))
 
     def test_path_to_tree_path_error(self):
         with self.assertRaises(ValueError):
             with tempfile.TemporaryDirectory() as od:
                 porcelain.path_to_tree_path(od, self.fp)
 
     def test_path_to_tree_path_rel(self):
         cwd = os.getcwd()
         os.mkdir(os.path.join(self.repo.path, "foo"))
         os.mkdir(os.path.join(self.repo.path, "foo/bar"))
         try:
             os.chdir(os.path.join(self.repo.path, "foo/bar"))
             with open("baz", "w") as f:
                 f.write("contents")
             self.assertEqual(b"bar/baz", porcelain.path_to_tree_path("..", "baz"))
             self.assertEqual(
                 b"bar/baz",
                 porcelain.path_to_tree_path(
                     os.path.join(os.getcwd(), ".."),
                     os.path.join(os.getcwd(), "baz"),
                 ),
             )
             self.assertEqual(
                 b"bar/baz",
                 porcelain.path_to_tree_path("..", os.path.join(os.getcwd(), "baz")),
             )
             self.assertEqual(
                 b"bar/baz",
                 porcelain.path_to_tree_path(os.path.join(os.getcwd(), ".."), "baz"),
             )
         finally:
             os.chdir(cwd)
 
 
 class GetObjectByPathTests(PorcelainTestCase):
     def test_simple(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
         )
         self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, "foo").data)
         self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, b"foo").data)
 
     def test_encoding(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         porcelain.commit(
             self.repo.path,
             message=b"Some message",
             author=b"Joe <joe@example.com>",
             committer=b"Bob <bob@example.com>",
             encoding=b"utf-8",
         )
         self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, "foo").data)
         self.assertEqual(b"BAR", porcelain.get_object_by_path(self.repo, b"foo").data)
 
     def test_missing(self):
         self.assertRaises(KeyError, porcelain.get_object_by_path, self.repo, "foo")
 
 
 class WriteTreeTests(PorcelainTestCase):
     def test_simple(self):
         fullpath = os.path.join(self.repo.path, "foo")
         with open(fullpath, "w") as f:
             f.write("BAR")
         porcelain.add(repo=self.repo.path, paths=[fullpath])
         self.assertEqual(
             b"d2092c8a9f311f0311083bf8d177f2ca0ab5b241",
             porcelain.write_tree(self.repo),
         )
 
 
 class ActiveBranchTests(PorcelainTestCase):
     def test_simple(self):
         self.assertEqual(b"master", porcelain.active_branch(self.repo))
diff --git a/dulwich/tests/test_repository.py b/dulwich/tests/test_repository.py
index 9495d2f1..4b75e043 100644
--- a/dulwich/tests/test_repository.py
+++ b/dulwich/tests/test_repository.py
@@ -1,1276 +1,1292 @@
 # -*- coding: utf-8 -*-
 # test_repository.py -- tests for repository.py
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 #
 # 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 repository."""
 
+import glob
 import locale
 import os
-import stat
 import shutil
+import stat
 import sys
 import tempfile
 import warnings
 
 from dulwich import errors
 from dulwich.object_store import (
     tree_lookup_path,
 )
 from dulwich import objects
 from dulwich.config import Config
 from dulwich.errors import NotGitRepository
 from dulwich.repo import (
     InvalidUserIdentity,
     Repo,
     MemoryRepo,
     check_user_identity,
     UnsupportedVersion,
 )
 from dulwich.tests import (
     TestCase,
     skipIf,
 )
 from dulwich.tests.utils import (
     open_repo,
     tear_down_repo,
     setup_warning_catcher,
 )
 
 missing_sha = b"b91fa4d900e17e99b433218e988c4eb4a3e9a097"
 
 
 class CreateRepositoryTests(TestCase):
     def assertFileContentsEqual(self, expected, repo, path):
         f = repo.get_named_file(path)
         if not f:
             self.assertEqual(expected, None)
         else:
             with f:
                 self.assertEqual(expected, f.read())
 
     def _check_repo_contents(self, repo, expect_bare):
         self.assertEqual(expect_bare, repo.bare)
         self.assertFileContentsEqual(b"Unnamed repository", repo, "description")
         self.assertFileContentsEqual(b"", repo, os.path.join("info", "exclude"))
         self.assertFileContentsEqual(None, repo, "nonexistent file")
         barestr = b"bare = " + str(expect_bare).lower().encode("ascii")
         with repo.get_named_file("config") as f:
             config_text = f.read()
             self.assertTrue(barestr in config_text, "%r" % config_text)
         expect_filemode = sys.platform != "win32"
         barestr = b"filemode = " + str(expect_filemode).lower().encode("ascii")
         with repo.get_named_file("config") as f:
             config_text = f.read()
             self.assertTrue(barestr in config_text, "%r" % config_text)
 
+        if isinstance(repo, Repo):
+            expected_mode = '0o100644' if expect_filemode else '0o100666'
+            expected = {
+                'HEAD': expected_mode,
+                'config': expected_mode,
+                'description': expected_mode,
+            }
+            actual = {
+                f[len(repo._controldir) + 1:]: oct(os.stat(f).st_mode)
+                for f in glob.glob(os.path.join(repo._controldir, '*'))
+                if os.path.isfile(f)
+            }
+
+            self.assertEqual(expected, actual)
+
     def test_create_memory(self):
         repo = MemoryRepo.init_bare([], {})
         self._check_repo_contents(repo, True)
 
     def test_create_disk_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init_bare(tmp_dir)
         self.assertEqual(tmp_dir, repo._controldir)
         self._check_repo_contents(repo, True)
 
     def test_create_disk_non_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
         self.assertEqual(os.path.join(tmp_dir, ".git"), repo._controldir)
         self._check_repo_contents(repo, False)
 
     def test_create_disk_non_bare_mkdir(self):
         tmp_dir = tempfile.mkdtemp()
         target_dir = os.path.join(tmp_dir, "target")
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(target_dir, mkdir=True)
         self.assertEqual(os.path.join(target_dir, ".git"), repo._controldir)
         self._check_repo_contents(repo, False)
 
     def test_create_disk_bare_mkdir(self):
         tmp_dir = tempfile.mkdtemp()
         target_dir = os.path.join(tmp_dir, "target")
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init_bare(target_dir, mkdir=True)
         self.assertEqual(target_dir, repo._controldir)
         self._check_repo_contents(repo, True)
 
 
 class MemoryRepoTests(TestCase):
     def test_set_description(self):
         r = MemoryRepo.init_bare([], {})
         description = b"Some description"
         r.set_description(description)
         self.assertEqual(description, r.get_description())
 
 
 class RepositoryRootTests(TestCase):
     def mkdtemp(self):
         return tempfile.mkdtemp()
 
     def open_repo(self, name):
         temp_dir = self.mkdtemp()
         repo = open_repo(name, temp_dir)
         self.addCleanup(tear_down_repo, repo)
         return repo
 
     def test_simple_props(self):
         r = self.open_repo("a.git")
         self.assertEqual(r.controldir(), r.path)
 
     def test_setitem(self):
         r = self.open_repo("a.git")
         r[b"refs/tags/foo"] = b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"
         self.assertEqual(
             b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", r[b"refs/tags/foo"].id
         )
 
     def test_getitem_unicode(self):
         r = self.open_repo("a.git")
 
         test_keys = [
             (b"refs/heads/master", True),
             (b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", True),
             (b"11" * 19 + b"--", False),
         ]
 
         for k, contained in test_keys:
             self.assertEqual(k in r, contained)
 
         # Avoid deprecation warning under Py3.2+
         if getattr(self, "assertRaisesRegex", None):
             assertRaisesRegexp = self.assertRaisesRegex
         else:
             assertRaisesRegexp = self.assertRaisesRegexp
         for k, _ in test_keys:
             assertRaisesRegexp(
                 TypeError,
                 "'name' must be bytestring, not int",
                 r.__getitem__,
                 12,
             )
 
     def test_delitem(self):
         r = self.open_repo("a.git")
 
         del r[b"refs/heads/master"]
         self.assertRaises(KeyError, lambda: r[b"refs/heads/master"])
 
         del r[b"HEAD"]
         self.assertRaises(KeyError, lambda: r[b"HEAD"])
 
         self.assertRaises(ValueError, r.__delitem__, b"notrefs/foo")
 
     def test_get_refs(self):
         r = self.open_repo("a.git")
         self.assertEqual(
             {
                 b"HEAD": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
                 b"refs/heads/master": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
                 b"refs/tags/mytag": b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
                 b"refs/tags/mytag-packed": b"b0931cadc54336e78a1d980420e3268903b57a50",
             },
             r.get_refs(),
         )
 
     def test_head(self):
         r = self.open_repo("a.git")
         self.assertEqual(r.head(), b"a90fa2d900a17e99b433217e988c4eb4a2e9a097")
 
     def test_get_object(self):
         r = self.open_repo("a.git")
         obj = r.get_object(r.head())
         self.assertEqual(obj.type_name, b"commit")
 
     def test_get_object_non_existant(self):
         r = self.open_repo("a.git")
         self.assertRaises(KeyError, r.get_object, missing_sha)
 
     def test_contains_object(self):
         r = self.open_repo("a.git")
         self.assertTrue(r.head() in r)
         self.assertFalse(b"z" * 40 in r)
 
     def test_contains_ref(self):
         r = self.open_repo("a.git")
         self.assertTrue(b"HEAD" in r)
 
     def test_get_no_description(self):
         r = self.open_repo("a.git")
         self.assertIs(None, r.get_description())
 
     def test_get_description(self):
         r = self.open_repo("a.git")
         with open(os.path.join(r.path, "description"), "wb") as f:
             f.write(b"Some description")
         self.assertEqual(b"Some description", r.get_description())
 
     def test_set_description(self):
         r = self.open_repo("a.git")
         description = b"Some description"
         r.set_description(description)
         self.assertEqual(description, r.get_description())
 
     def test_contains_missing(self):
         r = self.open_repo("a.git")
         self.assertFalse(b"bar" in r)
 
     def test_get_peeled(self):
         # unpacked ref
         r = self.open_repo("a.git")
         tag_sha = b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a"
         self.assertNotEqual(r[tag_sha].sha().hexdigest(), r.head())
         self.assertEqual(r.get_peeled(b"refs/tags/mytag"), r.head())
 
         # packed ref with cached peeled value
         packed_tag_sha = b"b0931cadc54336e78a1d980420e3268903b57a50"
         parent_sha = r[r.head()].parents[0]
         self.assertNotEqual(r[packed_tag_sha].sha().hexdigest(), parent_sha)
         self.assertEqual(r.get_peeled(b"refs/tags/mytag-packed"), parent_sha)
 
         # TODO: add more corner cases to test repo
 
     def test_get_peeled_not_tag(self):
         r = self.open_repo("a.git")
         self.assertEqual(r.get_peeled(b"HEAD"), r.head())
 
     def test_get_parents(self):
         r = self.open_repo("a.git")
         self.assertEqual(
             [b"2a72d929692c41d8554c07f6301757ba18a65d91"],
             r.get_parents(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"),
         )
         r.update_shallow([b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"], None)
         self.assertEqual([], r.get_parents(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"))
 
     def test_get_walker(self):
         r = self.open_repo("a.git")
         # include defaults to [r.head()]
         self.assertEqual(
             [e.commit.id for e in r.get_walker()],
             [r.head(), b"2a72d929692c41d8554c07f6301757ba18a65d91"],
         )
         self.assertEqual(
             [
                 e.commit.id
                 for e in r.get_walker([b"2a72d929692c41d8554c07f6301757ba18a65d91"])
             ],
             [b"2a72d929692c41d8554c07f6301757ba18a65d91"],
         )
         self.assertEqual(
             [
                 e.commit.id
                 for e in r.get_walker(b"2a72d929692c41d8554c07f6301757ba18a65d91")
             ],
             [b"2a72d929692c41d8554c07f6301757ba18a65d91"],
         )
 
     def assertFilesystemHidden(self, path):
         if sys.platform != "win32":
             return
         import ctypes
         from ctypes.wintypes import DWORD, LPCWSTR
 
         GetFileAttributesW = ctypes.WINFUNCTYPE(DWORD, LPCWSTR)(
             ("GetFileAttributesW", ctypes.windll.kernel32)
         )
         self.assertTrue(2 & GetFileAttributesW(path))
 
     def test_init_existing(self):
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         t = Repo.init(tmp_dir)
         self.addCleanup(t.close)
         self.assertEqual(os.listdir(tmp_dir), [".git"])
         self.assertFilesystemHidden(os.path.join(tmp_dir, ".git"))
 
     def test_init_mkdir(self):
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo_dir = os.path.join(tmp_dir, "a-repo")
 
         t = Repo.init(repo_dir, mkdir=True)
         self.addCleanup(t.close)
         self.assertEqual(os.listdir(repo_dir), [".git"])
         self.assertFilesystemHidden(os.path.join(repo_dir, ".git"))
 
     def test_init_mkdir_unicode(self):
         repo_name = u"\xa7"
         try:
             os.fsencode(repo_name)
         except UnicodeEncodeError:
             self.skipTest("filesystem lacks unicode support")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo_dir = os.path.join(tmp_dir, repo_name)
 
         t = Repo.init(repo_dir, mkdir=True)
         self.addCleanup(t.close)
         self.assertEqual(os.listdir(repo_dir), [".git"])
         self.assertFilesystemHidden(os.path.join(repo_dir, ".git"))
 
     @skipIf(sys.platform == "win32", "fails on Windows")
     def test_fetch(self):
         r = self.open_repo("a.git")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         t = Repo.init(tmp_dir)
         self.addCleanup(t.close)
         r.fetch(t)
         self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
         self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
         self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
         self.assertIn(b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a", t)
         self.assertIn(b"b0931cadc54336e78a1d980420e3268903b57a50", t)
 
     @skipIf(sys.platform == "win32", "fails on Windows")
     def test_fetch_ignores_missing_refs(self):
         r = self.open_repo("a.git")
         missing = b"1234566789123456789123567891234657373833"
         r.refs[b"refs/heads/blah"] = missing
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         t = Repo.init(tmp_dir)
         self.addCleanup(t.close)
         r.fetch(t)
         self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
         self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
         self.assertIn(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097", t)
         self.assertIn(b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a", t)
         self.assertIn(b"b0931cadc54336e78a1d980420e3268903b57a50", t)
         self.assertNotIn(missing, t)
 
     def test_clone(self):
         r = self.open_repo("a.git")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         with r.clone(tmp_dir, mkdir=False) as t:
             self.assertEqual(
                 {
                     b"HEAD": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
                     b"refs/remotes/origin/master": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
                     b"refs/heads/master": b"a90fa2d900a17e99b433217e988c4eb4a2e9a097",
                     b"refs/tags/mytag": b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
                     b"refs/tags/mytag-packed": b"b0931cadc54336e78a1d980420e3268903b57a50",
                 },
                 t.refs.as_dict(),
             )
             shas = [e.commit.id for e in r.get_walker()]
             self.assertEqual(
                 shas, [t.head(), b"2a72d929692c41d8554c07f6301757ba18a65d91"]
             )
             c = t.get_config()
             encoded_path = r.path
             if not isinstance(encoded_path, bytes):
                 encoded_path = os.fsencode(encoded_path)
             self.assertEqual(encoded_path, c.get((b"remote", b"origin"), b"url"))
             self.assertEqual(
                 b"+refs/heads/*:refs/remotes/origin/*",
                 c.get((b"remote", b"origin"), b"fetch"),
             )
 
     def test_clone_no_head(self):
         temp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         repo_dir = os.path.join(os.path.dirname(__file__), "data", "repos")
         dest_dir = os.path.join(temp_dir, "a.git")
         shutil.copytree(os.path.join(repo_dir, "a.git"), dest_dir, symlinks=True)
         r = Repo(dest_dir)
         del r.refs[b"refs/heads/master"]
         del r.refs[b"HEAD"]
         t = r.clone(os.path.join(temp_dir, "b.git"), mkdir=True)
         self.assertEqual(
             {
                 b"refs/tags/mytag": b"28237f4dc30d0d462658d6b937b08a0f0b6ef55a",
                 b"refs/tags/mytag-packed": b"b0931cadc54336e78a1d980420e3268903b57a50",
             },
             t.refs.as_dict(),
         )
 
     def test_clone_empty(self):
         """Test clone() doesn't crash if HEAD points to a non-existing ref.
 
         This simulates cloning server-side bare repository either when it is
         still empty or if user renames master branch and pushes private repo
         to the server.
         Non-bare repo HEAD always points to an existing ref.
         """
         r = self.open_repo("empty.git")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         r.clone(tmp_dir, mkdir=False, bare=True)
 
     def test_clone_bare(self):
         r = self.open_repo("a.git")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         t = r.clone(tmp_dir, mkdir=False)
         t.close()
 
     def test_clone_checkout_and_bare(self):
         r = self.open_repo("a.git")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         self.assertRaises(
             ValueError, r.clone, tmp_dir, mkdir=False, checkout=True, bare=True
         )
 
     def test_merge_history(self):
         r = self.open_repo("simple_merge.git")
         shas = [e.commit.id for e in r.get_walker()]
         self.assertEqual(
             shas,
             [
                 b"5dac377bdded4c9aeb8dff595f0faeebcc8498cc",
                 b"ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd",
                 b"4cffe90e0a41ad3f5190079d7c8f036bde29cbe6",
                 b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e",
                 b"0d89f20333fbb1d2f3a94da77f4981373d8f4310",
             ],
         )
 
     def test_out_of_order_merge(self):
         """Test that revision history is ordered by date, not parent order."""
         r = self.open_repo("ooo_merge.git")
         shas = [e.commit.id for e in r.get_walker()]
         self.assertEqual(
             shas,
             [
                 b"7601d7f6231db6a57f7bbb79ee52e4d462fd44d1",
                 b"f507291b64138b875c28e03469025b1ea20bc614",
                 b"fb5b0425c7ce46959bec94d54b9a157645e114f5",
                 b"f9e39b120c68182a4ba35349f832d0e4e61f485c",
             ],
         )
 
     def test_get_tags_empty(self):
         r = self.open_repo("ooo_merge.git")
         self.assertEqual({}, r.refs.as_dict(b"refs/tags"))
 
     def test_get_config(self):
         r = self.open_repo("ooo_merge.git")
         self.assertIsInstance(r.get_config(), Config)
 
     def test_get_config_stack(self):
         r = self.open_repo("ooo_merge.git")
         self.assertIsInstance(r.get_config_stack(), Config)
 
     def test_common_revisions(self):
         """
         This test demonstrates that ``find_common_revisions()`` actually
         returns common heads, not revisions; dulwich already uses
         ``find_common_revisions()`` in such a manner (see
         ``Repo.fetch_objects()``).
         """
 
         expected_shas = set([b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e"])
 
         # Source for objects.
         r_base = self.open_repo("simple_merge.git")
 
         # Re-create each-side of the merge in simple_merge.git.
         #
         # Since the trees and blobs are missing, the repository created is
         # corrupted, but we're only checking for commits for the purpose of
         # this test, so it's immaterial.
         r1_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, r1_dir)
         r1_commits = [
             b"ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd",  # HEAD
             b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e",
             b"0d89f20333fbb1d2f3a94da77f4981373d8f4310",
         ]
 
         r2_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, r2_dir)
         r2_commits = [
             b"4cffe90e0a41ad3f5190079d7c8f036bde29cbe6",  # HEAD
             b"60dacdc733de308bb77bb76ce0fb0f9b44c9769e",
             b"0d89f20333fbb1d2f3a94da77f4981373d8f4310",
         ]
 
         r1 = Repo.init_bare(r1_dir)
         for c in r1_commits:
             r1.object_store.add_object(r_base.get_object(c))
         r1.refs[b"HEAD"] = r1_commits[0]
 
         r2 = Repo.init_bare(r2_dir)
         for c in r2_commits:
             r2.object_store.add_object(r_base.get_object(c))
         r2.refs[b"HEAD"] = r2_commits[0]
 
         # Finally, the 'real' testing!
         shas = r2.object_store.find_common_revisions(r1.get_graph_walker())
         self.assertEqual(set(shas), expected_shas)
 
         shas = r1.object_store.find_common_revisions(r2.get_graph_walker())
         self.assertEqual(set(shas), expected_shas)
 
     def test_shell_hook_pre_commit(self):
         if os.name != "posix":
             self.skipTest("shell hook tests requires POSIX shell")
 
         pre_commit_fail = """#!/bin/sh
 exit 1
 """
 
         pre_commit_success = """#!/bin/sh
 exit 0
 """
 
         repo_dir = os.path.join(self.mkdtemp())
         self.addCleanup(shutil.rmtree, repo_dir)
         r = Repo.init(repo_dir)
         self.addCleanup(r.close)
 
         pre_commit = os.path.join(r.controldir(), "hooks", "pre-commit")
 
         with open(pre_commit, "w") as f:
             f.write(pre_commit_fail)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         self.assertRaises(
             errors.CommitError,
             r.do_commit,
             "failed commit",
             committer="Test Committer <test@nodomain.com>",
             author="Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
 
         with open(pre_commit, "w") as f:
             f.write(pre_commit_success)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b"empty commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual([], r[commit_sha].parents)
 
     def test_shell_hook_commit_msg(self):
         if os.name != "posix":
             self.skipTest("shell hook tests requires POSIX shell")
 
         commit_msg_fail = """#!/bin/sh
 exit 1
 """
 
         commit_msg_success = """#!/bin/sh
 exit 0
 """
 
         repo_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         r = Repo.init(repo_dir)
         self.addCleanup(r.close)
 
         commit_msg = os.path.join(r.controldir(), "hooks", "commit-msg")
 
         with open(commit_msg, "w") as f:
             f.write(commit_msg_fail)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         self.assertRaises(
             errors.CommitError,
             r.do_commit,
             b"failed commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
 
         with open(commit_msg, "w") as f:
             f.write(commit_msg_success)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b"empty commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual([], r[commit_sha].parents)
 
     def test_shell_hook_post_commit(self):
         if os.name != "posix":
             self.skipTest("shell hook tests requires POSIX shell")
 
         repo_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
 
         r = Repo.init(repo_dir)
         self.addCleanup(r.close)
 
         (fd, path) = tempfile.mkstemp(dir=repo_dir)
         os.close(fd)
         post_commit_msg = (
             """#!/bin/sh
 rm """
             + path
             + """
 """
         )
 
         root_sha = r.do_commit(
             b"empty commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         self.assertEqual([], r[root_sha].parents)
 
         post_commit = os.path.join(r.controldir(), "hooks", "post-commit")
 
         with open(post_commit, "wb") as f:
             f.write(post_commit_msg.encode(locale.getpreferredencoding()))
         os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b"empty commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         self.assertEqual([root_sha], r[commit_sha].parents)
 
         self.assertFalse(os.path.exists(path))
 
         post_commit_msg_fail = """#!/bin/sh
 exit 1
 """
         with open(post_commit, "w") as f:
             f.write(post_commit_msg_fail)
         os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         warnings.simplefilter("always", UserWarning)
         self.addCleanup(warnings.resetwarnings)
         warnings_list, restore_warnings = setup_warning_catcher()
         self.addCleanup(restore_warnings)
 
         commit_sha2 = r.do_commit(
             b"empty commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         expected_warning = UserWarning(
             "post-commit hook failed: Hook post-commit exited with "
             "non-zero status 1",
         )
         for w in warnings_list:
             if type(w) == type(expected_warning) and w.args == expected_warning.args:
                 break
         else:
             raise AssertionError(
                 "Expected warning %r not in %r" % (expected_warning, warnings_list)
             )
         self.assertEqual([commit_sha], r[commit_sha2].parents)
 
     def test_as_dict(self):
         def check(repo):
             self.assertEqual(
                 repo.refs.subkeys(b"refs/tags"),
                 repo.refs.subkeys(b"refs/tags/"),
             )
             self.assertEqual(
                 repo.refs.as_dict(b"refs/tags"),
                 repo.refs.as_dict(b"refs/tags/"),
             )
             self.assertEqual(
                 repo.refs.as_dict(b"refs/heads"),
                 repo.refs.as_dict(b"refs/heads/"),
             )
 
         bare = self.open_repo("a.git")
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         with bare.clone(tmp_dir, mkdir=False) as nonbare:
             check(nonbare)
             check(bare)
 
     def test_working_tree(self):
         temp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         worktree_temp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, worktree_temp_dir)
         r = Repo.init(temp_dir)
         self.addCleanup(r.close)
         root_sha = r.do_commit(
             b"empty commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         r.refs[b"refs/heads/master"] = root_sha
         w = Repo._init_new_working_directory(worktree_temp_dir, r)
         self.addCleanup(w.close)
         new_sha = w.do_commit(
             b"new commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         w.refs[b"HEAD"] = new_sha
         self.assertEqual(
             os.path.abspath(r.controldir()), os.path.abspath(w.commondir())
         )
         self.assertEqual(r.refs.keys(), w.refs.keys())
         self.assertNotEqual(r.head(), w.head())
 
 
 class BuildRepoRootTests(TestCase):
     """Tests that build on-disk repos from scratch.
 
     Repos live in a temp dir and are torn down after each test. They start with
     a single commit in master having single file named 'a'.
     """
 
     def get_repo_dir(self):
         return os.path.join(tempfile.mkdtemp(), "test")
 
     def setUp(self):
         super(BuildRepoRootTests, self).setUp()
         self._repo_dir = self.get_repo_dir()
         os.makedirs(self._repo_dir)
         r = self._repo = Repo.init(self._repo_dir)
         self.addCleanup(tear_down_repo, r)
         self.assertFalse(r.bare)
         self.assertEqual(b"ref: refs/heads/master", r.refs.read_ref(b"HEAD"))
         self.assertRaises(KeyError, lambda: r.refs[b"refs/heads/master"])
 
         with open(os.path.join(r.path, "a"), "wb") as f:
             f.write(b"file contents")
         r.stage(["a"])
         commit_sha = r.do_commit(
             b"msg",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         self.assertEqual([], r[commit_sha].parents)
         self._root_commit = commit_sha
 
     def test_get_shallow(self):
         self.assertEqual(set(), self._repo.get_shallow())
         with open(os.path.join(self._repo.path, ".git", "shallow"), "wb") as f:
             f.write(b"a90fa2d900a17e99b433217e988c4eb4a2e9a097\n")
         self.assertEqual(
             {b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"},
             self._repo.get_shallow(),
         )
 
     def test_update_shallow(self):
         self._repo.update_shallow(None, None)  # no op
         self.assertEqual(set(), self._repo.get_shallow())
         self._repo.update_shallow([b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"], None)
         self.assertEqual(
             {b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"},
             self._repo.get_shallow(),
         )
         self._repo.update_shallow(
             [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
             [b"f9e39b120c68182a4ba35349f832d0e4e61f485c"],
         )
         self.assertEqual(
             {b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"},
             self._repo.get_shallow(),
         )
         self._repo.update_shallow(
             None, [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"]
         )
         self.assertEqual(set(), self._repo.get_shallow())
         self.assertEqual(
             False,
             os.path.exists(os.path.join(self._repo.controldir(), "shallow")),
         )
 
     def test_build_repo(self):
         r = self._repo
         self.assertEqual(b"ref: refs/heads/master", r.refs.read_ref(b"HEAD"))
         self.assertEqual(self._root_commit, r.refs[b"refs/heads/master"])
         expected_blob = objects.Blob.from_string(b"file contents")
         self.assertEqual(expected_blob.data, r[expected_blob.id].data)
         actual_commit = r[self._root_commit]
         self.assertEqual(b"msg", actual_commit.message)
 
     def test_commit_modified(self):
         r = self._repo
         with open(os.path.join(r.path, "a"), "wb") as f:
             f.write(b"new contents")
         r.stage(["a"])
         commit_sha = r.do_commit(
             b"modified a",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         a_mode, a_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b"a")
         self.assertEqual(stat.S_IFREG | 0o644, a_mode)
         self.assertEqual(b"new contents", r[a_id].data)
 
     @skipIf(not getattr(os, "symlink", None), "Requires symlink support")
     def test_commit_symlink(self):
         r = self._repo
         os.symlink("a", os.path.join(r.path, "b"))
         r.stage(["a", "b"])
         commit_sha = r.do_commit(
             b"Symlink b",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         b_mode, b_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b"b")
         self.assertTrue(stat.S_ISLNK(b_mode))
         self.assertEqual(b"a", r[b_id].data)
 
     def test_commit_merge_heads_file(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         r = Repo.init(tmp_dir)
         with open(os.path.join(r.path, "a"), "w") as f:
             f.write("initial text")
         c1 = r.do_commit(
             b"initial commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         with open(os.path.join(r.path, "a"), "w") as f:
             f.write("merged text")
         with open(os.path.join(r.path, ".git", "MERGE_HEAD"), "w") as f:
             f.write("c27a2d21dd136312d7fa9e8baabb82561a1727d0\n")
         r.stage(["a"])
         commit_sha = r.do_commit(
             b"deleted a",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual(
             [c1, b"c27a2d21dd136312d7fa9e8baabb82561a1727d0"],
             r[commit_sha].parents,
         )
 
     def test_commit_deleted(self):
         r = self._repo
         os.remove(os.path.join(r.path, "a"))
         r.stage(["a"])
         commit_sha = r.do_commit(
             b"deleted a",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         self.assertEqual([], list(r.open_index()))
         tree = r[r[commit_sha].tree]
         self.assertEqual([], list(tree.iteritems()))
 
     def test_commit_follows(self):
         r = self._repo
         r.refs.set_symbolic_ref(b"HEAD", b"refs/heads/bla")
         commit_sha = r.do_commit(
             b"commit with strange character",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=b"HEAD",
         )
         self.assertEqual(commit_sha, r[b"refs/heads/bla"].id)
 
     def test_commit_encoding(self):
         r = self._repo
         commit_sha = r.do_commit(
             b"commit with strange character \xee",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             encoding=b"iso8859-1",
         )
         self.assertEqual(b"iso8859-1", r[commit_sha].encoding)
 
     def test_compression_level(self):
         r = self._repo
         c = r.get_config()
         c.set(("core",), "compression", "3")
         c.set(("core",), "looseCompression", "4")
         c.write_to_path()
         r = Repo(self._repo_dir)
         self.assertEqual(r.object_store.loose_compression_level, 4)
 
     def test_repositoryformatversion(self):
         r = self._repo
         c = r.get_config()
         c.set(("core",), "repositoryformatversion", "2")
         c.write_to_path()
         self.assertRaises(UnsupportedVersion, Repo, self._repo_dir)
 
     def test_commit_encoding_from_config(self):
         r = self._repo
         c = r.get_config()
         c.set(("i18n",), "commitEncoding", "iso8859-1")
         c.write_to_path()
         commit_sha = r.do_commit(
             b"commit with strange character \xee",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
         )
         self.assertEqual(b"iso8859-1", r[commit_sha].encoding)
 
     def test_commit_config_identity(self):
         # commit falls back to the users' identity if it wasn't specified
         r = self._repo
         c = r.get_config()
         c.set((b"user",), b"name", b"Jelmer")
         c.set((b"user",), b"email", b"jelmer@apache.org")
         c.write_to_path()
         commit_sha = r.do_commit(b"message")
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].committer)
 
     def test_commit_config_identity_strips_than(self):
         # commit falls back to the users' identity if it wasn't specified,
         # and strips superfluous <>
         r = self._repo
         c = r.get_config()
         c.set((b"user",), b"name", b"Jelmer")
         c.set((b"user",), b"email", b"<jelmer@apache.org>")
         c.write_to_path()
         commit_sha = r.do_commit(b"message")
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].committer)
 
     def test_commit_config_identity_in_memoryrepo(self):
         # commit falls back to the users' identity if it wasn't specified
         r = MemoryRepo.init_bare([], {})
         c = r.get_config()
         c.set((b"user",), b"name", b"Jelmer")
         c.set((b"user",), b"email", b"jelmer@apache.org")
 
         commit_sha = r.do_commit(b"message", tree=objects.Tree().id)
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].committer)
 
     def overrideEnv(self, name, value):
         def restore():
             if oldval is not None:
                 os.environ[name] = oldval
             else:
                 del os.environ[name]
 
         oldval = os.environ.get(name)
         os.environ[name] = value
         self.addCleanup(restore)
 
     def test_commit_config_identity_from_env(self):
         # commit falls back to the users' identity if it wasn't specified
         self.overrideEnv("GIT_COMMITTER_NAME", "joe")
         self.overrideEnv("GIT_COMMITTER_EMAIL", "joe@example.com")
         r = self._repo
         c = r.get_config()
         c.set((b"user",), b"name", b"Jelmer")
         c.set((b"user",), b"email", b"jelmer@apache.org")
         c.write_to_path()
         commit_sha = r.do_commit(b"message")
         self.assertEqual(b"Jelmer <jelmer@apache.org>", r[commit_sha].author)
         self.assertEqual(b"joe <joe@example.com>", r[commit_sha].committer)
 
     def test_commit_fail_ref(self):
         r = self._repo
 
         def set_if_equals(name, old_ref, new_ref, **kwargs):
             return False
 
         r.refs.set_if_equals = set_if_equals
 
         def add_if_new(name, new_ref, **kwargs):
             self.fail("Unexpected call to add_if_new")
 
         r.refs.add_if_new = add_if_new
 
         old_shas = set(r.object_store)
         self.assertRaises(
             errors.CommitError,
             r.do_commit,
             b"failed commit",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12345,
             commit_timezone=0,
             author_timestamp=12345,
             author_timezone=0,
         )
         new_shas = set(r.object_store) - old_shas
         self.assertEqual(1, len(new_shas))
         # Check that the new commit (now garbage) was added.
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual(b"failed commit", new_commit.message)
 
     def test_commit_branch(self):
         r = self._repo
 
         commit_sha = r.do_commit(
             b"commit to branch",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=b"refs/heads/new_branch",
         )
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([], r[commit_sha].parents)
         self.assertTrue(b"refs/heads/new_branch" in r)
 
         new_branch_head = commit_sha
 
         commit_sha = r.do_commit(
             b"commit to branch 2",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=b"refs/heads/new_branch",
         )
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([new_branch_head], r[commit_sha].parents)
 
     def test_commit_merge_heads(self):
         r = self._repo
         merge_1 = r.do_commit(
             b"commit to branch 2",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=b"refs/heads/new_branch",
         )
         commit_sha = r.do_commit(
             b"commit with merge",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             merge_heads=[merge_1],
         )
         self.assertEqual([self._root_commit, merge_1], r[commit_sha].parents)
 
     def test_commit_dangling_commit(self):
         r = self._repo
 
         old_shas = set(r.object_store)
         old_refs = r.get_refs()
         commit_sha = r.do_commit(
             b"commit with no ref",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=None,
         )
         new_shas = set(r.object_store) - old_shas
 
         # New sha is added, but no new refs
         self.assertEqual(1, len(new_shas))
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual([], r[commit_sha].parents)
         self.assertEqual(old_refs, r.get_refs())
 
     def test_commit_dangling_commit_with_parents(self):
         r = self._repo
 
         old_shas = set(r.object_store)
         old_refs = r.get_refs()
         commit_sha = r.do_commit(
             b"commit with no ref",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=None,
             merge_heads=[self._root_commit],
         )
         new_shas = set(r.object_store) - old_shas
 
         # New sha is added, but no new refs
         self.assertEqual(1, len(new_shas))
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         self.assertEqual(old_refs, r.get_refs())
 
     def test_stage_absolute(self):
         r = self._repo
         os.remove(os.path.join(r.path, "a"))
         self.assertRaises(ValueError, r.stage, [os.path.join(r.path, "a")])
 
     def test_stage_deleted(self):
         r = self._repo
         os.remove(os.path.join(r.path, "a"))
         r.stage(["a"])
         r.stage(["a"])  # double-stage a deleted path
 
     def test_stage_directory(self):
         r = self._repo
         os.mkdir(os.path.join(r.path, "c"))
         r.stage(["c"])
         self.assertEqual([b"a"], list(r.open_index()))
 
     @skipIf(
         sys.platform in ("win32", "darwin"),
         "tries to implicitly decode as utf8",
     )
     def test_commit_no_encode_decode(self):
         r = self._repo
         repo_path_bytes = os.fsencode(r.path)
         encodings = ("utf8", "latin1")
         names = [u"À".encode(encoding) for encoding in encodings]
         for name, encoding in zip(names, encodings):
             full_path = os.path.join(repo_path_bytes, name)
             with open(full_path, "wb") as f:
                 f.write(encoding.encode("ascii"))
             # These files are break tear_down_repo, so cleanup these files
             # ourselves.
             self.addCleanup(os.remove, full_path)
 
         r.stage(names)
         commit_sha = r.do_commit(
             b"Files with different encodings",
             committer=b"Test Committer <test@nodomain.com>",
             author=b"Test Author <test@nodomain.com>",
             commit_timestamp=12395,
             commit_timezone=0,
             author_timestamp=12395,
             author_timezone=0,
             ref=None,
             merge_heads=[self._root_commit],
         )
 
         for name, encoding in zip(names, encodings):
             mode, id = tree_lookup_path(r.get_object, r[commit_sha].tree, name)
             self.assertEqual(stat.S_IFREG | 0o644, mode)
             self.assertEqual(encoding.encode("ascii"), r[id].data)
 
     def test_discover_intended(self):
         path = os.path.join(self._repo_dir, "b/c")
         r = Repo.discover(path)
         self.assertEqual(r.head(), self._repo.head())
 
     def test_discover_isrepo(self):
         r = Repo.discover(self._repo_dir)
         self.assertEqual(r.head(), self._repo.head())
 
     def test_discover_notrepo(self):
         with self.assertRaises(NotGitRepository):
             Repo.discover("/")
 
 
 class CheckUserIdentityTests(TestCase):
     def test_valid(self):
         check_user_identity(b"Me <me@example.com>")
 
     def test_invalid(self):
         self.assertRaises(InvalidUserIdentity, check_user_identity, b"No Email")
         self.assertRaises(
             InvalidUserIdentity, check_user_identity, b"Fullname <missing"
         )
         self.assertRaises(
             InvalidUserIdentity, check_user_identity, b"Fullname missing>"
         )
         self.assertRaises(
             InvalidUserIdentity, check_user_identity, b"Fullname >order<>"
         )
diff --git a/releaser.conf b/releaser.conf
index cf6b7a35..bcad72df 100644
--- a/releaser.conf
+++ b/releaser.conf
@@ -1,14 +1,15 @@
+# See https://github.com/jelmer/releaser
 news_file: "NEWS"
 timeout_days: 5
 tag_name: "dulwich-$VERSION"
 verify_command: "make check"
 update_version {
   path: "setup.py"
   match: "^dulwich_version_string = '(.*)'$"
   new_line: "dulwich_version_string = '$VERSION'"
 }
 update_version {
   path: "dulwich/__init__.py"
   match: "^__version__ = \((.*)\)$"
   new_line: "__version__ = $TUPLED_VERSION"
 }
diff --git a/setup.py b/setup.py
index c9da33d2..8168ef69 100755
--- a/setup.py
+++ b/setup.py
@@ -1,135 +1,136 @@
 #!/usr/bin/python3
 # encoding: utf-8
 # Setup file for dulwich
 # Copyright (C) 2008-2016 Jelmer Vernooij <jelmer@jelmer.uk>
 
 try:
     from setuptools import setup, Extension
 except ImportError:
     from distutils.core import setup, Extension
     has_setuptools = False
 else:
     has_setuptools = True
 from distutils.core import Distribution
 import io
 import os
 import sys
 from typing import Dict, Any
 
 
 if sys.version_info < (3, 5):
     raise Exception(
         'Dulwich only supports Python 3.5 and later. '
         'For 2.7 support, please install a version prior to 0.20')
 
 
-dulwich_version_string = '0.20.23'
+dulwich_version_string = '0.20.25'
 
 
 class DulwichDistribution(Distribution):
 
     def is_pure(self):
         if self.pure:
             return True
 
     def has_ext_modules(self):
         return not self.pure
 
     global_options = Distribution.global_options + [
         ('pure', None, "use pure Python code instead of C "
                        "extensions (slower on CPython)")]
 
     pure = False
 
 
 if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
     # XCode 4.0 dropped support for ppc architecture, which is hardcoded in
     # distutils.sysconfig
     import subprocess
     p = subprocess.Popen(
         ['/usr/bin/xcodebuild', '-version'], stdout=subprocess.PIPE,
         stderr=subprocess.PIPE, env={})
     out, err = p.communicate()
     for line in out.splitlines():
         line = line.decode("utf8")
         # Also parse only first digit, because 3.2.1 can't be parsed nicely
         if (line.startswith('Xcode') and
                 int(line.split()[1].split('.')[0]) >= 4):
             os.environ['ARCHFLAGS'] = ''
 
 tests_require = ['fastimport']
 
 
 if '__pypy__' not in sys.modules and sys.platform != 'win32':
     tests_require.extend([
         'gevent', 'geventhttpclient', 'setuptools>=17.1'])
 
 
 ext_modules = [
     Extension('dulwich._objects', ['dulwich/_objects.c']),
     Extension('dulwich._pack', ['dulwich/_pack.c']),
     Extension('dulwich._diff_tree', ['dulwich/_diff_tree.c']),
 ]
 
 setup_kwargs = {}  # type: Dict[str, Any]
 scripts = ['bin/dul-receive-pack', 'bin/dul-upload-pack']
 if has_setuptools:
     setup_kwargs['extras_require'] = {
         'fastimport': ['fastimport'],
         'https': ['urllib3[secure]>=1.24.1'],
         'pgp': ['gpg'],
         'watch': ['pyinotify'],
         }
     setup_kwargs['install_requires'] = ['urllib3>=1.24.1', 'certifi']
     setup_kwargs['include_package_data'] = True
     setup_kwargs['test_suite'] = 'dulwich.tests.test_suite'
     setup_kwargs['tests_require'] = tests_require
     setup_kwargs['entry_points'] = {
         "console_scripts": [
             "dulwich=dulwich.cli:main",
         ]}
     setup_kwargs['python_requires'] = '>=3.5'
 else:
     scripts.append('bin/dulwich')
 
 
 with io.open(os.path.join(os.path.dirname(__file__), "README.rst"),
              encoding="utf-8") as f:
     description = f.read()
 
 setup(name='dulwich',
       author="Jelmer Vernooij",
       author_email="jelmer@jelmer.uk",
       url="https://www.dulwich.io/",
       long_description=description,
       description="Python Git Library",
       version=dulwich_version_string,
       license='Apachev2 or later or GPLv2',
       project_urls={
           "Bug Tracker": "https://github.com/dulwich/dulwich/issues",
           "Repository": "https://www.dulwich.io/code/",
           "GitHub": "https://github.com/dulwich/dulwich",
       },
       keywords="git vcs",
       packages=['dulwich', 'dulwich.tests', 'dulwich.tests.compat',
                 'dulwich.contrib'],
       package_data={'': ['../docs/tutorial/*.txt', 'py.typed']},
       scripts=scripts,
       ext_modules=ext_modules,
+      zip_safe=False,
       distclass=DulwichDistribution,
       classifiers=[
           'Development Status :: 4 - Beta',
           'License :: OSI Approved :: Apache Software License',
           'Programming Language :: Python :: 3.5',
           'Programming Language :: Python :: 3.6',
           'Programming Language :: Python :: 3.7',
           'Programming Language :: Python :: 3.8',
           'Programming Language :: Python :: 3.9',
           'Programming Language :: Python :: Implementation :: CPython',
           'Programming Language :: Python :: Implementation :: PyPy',
           'Operating System :: POSIX',
           'Operating System :: Microsoft :: Windows',
           'Topic :: Software Development :: Version Control',
       ],
       **setup_kwargs
       )