diff --git a/docs/tutorial/remote.txt b/docs/tutorial/remote.txt
index 727c3f41..94fd0a48 100644
--- a/docs/tutorial/remote.txt
+++ b/docs/tutorial/remote.txt
@@ -1,84 +1,87 @@
 .. _tutorial-remote:
 
 Most of the tests in this file require a Dulwich server, so let's start one:
 
     >>> from dulwich.repo import Repo
     >>> from dulwich.server import DictBackend, TCPGitServer
     >>> import threading
     >>> repo = Repo.init("remote", mkdir=True)
     >>> cid = repo.do_commit(b"message", committer=b"Jelmer <jelmer@samba.org>")
     >>> backend = DictBackend({b'/': repo})
     >>> dul_server = TCPGitServer(backend, b'localhost', 0)
     >>> threading.Thread(target=dul_server.serve).start()
     >>> server_address, server_port=dul_server.socket.getsockname()
 
 Remote repositories
 ===================
 
 The interface for remote Git repositories is different from that
 for local repositories.
 
 The Git smart server protocol provides three basic operations:
 
  * upload-pack - provides a pack with objects requested by the client
  * receive-pack - imports a pack with objects provided by the client
  * upload-archive - provides a tarball with the contents of a specific revision
 
 The smart server protocol can be accessed over either plain TCP (git://),
 SSH (git+ssh://) or tunneled over HTTP (http://).
 
 Dulwich provides support for accessing remote repositories in
 ``dulwich.client``. To create a new client, you can construct
 one manually::
 
    >>> from dulwich.client import TCPGitClient
    >>> client = TCPGitClient(server_address, server_port)
 
 Retrieving raw pack files
 -------------------------
 
 The client object can then be used to retrieve a pack. The ``fetch_pack``
 method takes a ``determine_wants`` callback argument, which allows the
 client to determine which objects it wants to end up with::
 
-   >>> def determine_wants(refs):
+   >>> def determine_wants(refs, depth=None):
    ...    # retrieve all objects
    ...    return refs.values()
 
+Note that the ``depth`` keyword argument will contain an optional requested
+shallow fetch depth.
+
 Another required object is a "graph walker", which is used to determine
 which objects that the client already has should not be sent again
 by the server. Here in the tutorial we'll just use a dummy graph walker
 which claims that the client doesn't have any objects::
 
    >>> class DummyGraphWalker(object):
    ...     def ack(self, sha): pass
    ...     def next(self): pass
    ...     def __next__(self): pass
 
 With the ``determine_wants`` function in place, we can now fetch a pack,
 which we will write to a ``BytesIO`` object::
 
    >>> from io import BytesIO
    >>> f = BytesIO()
    >>> result = client.fetch_pack(b"/", determine_wants,
    ...    DummyGraphWalker(), pack_data=f.write)
 
 ``f`` will now contain a full pack file::
 
    >>> print(f.getvalue()[:4].decode('ascii'))
    PACK
 
 Fetching objects into a local repository
 ----------------------------------------
 
 It is also possible to fetch from a remote repository into a local repository,
 in which case Dulwich takes care of providing the right graph walker, and
 importing the received pack file into the local repository::
 
    >>> from dulwich.repo import Repo
    >>> local = Repo.init("local", mkdir=True)
    >>> remote_refs = client.fetch(b"/", local)
 
 Let's shut down the server now that all tests have been run::
 
    >>> dul_server.shutdown()
diff --git a/dulwich/cli.py b/dulwich/cli.py
index cf1074a3..bcdd094b 100755
--- a/dulwich/cli.py
+++ b/dulwich/cli.py
@@ -1,755 +1,755 @@
 #!/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):
+            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
 
     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__":
     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:]))
diff --git a/dulwich/client.py b/dulwich/client.py
index ca03f251..5dc36cae 100644
--- a/dulwich/client.py
+++ b/dulwich/client.py
@@ -1,2194 +1,2194 @@
 # 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
 
 
 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.
           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)
           generate_pack_data: Function that can return a tuple with
         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.
           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:
-                wants = determine_wants(refs)
+                wants = determine_wants(refs, depth=depth)
             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.
           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.
           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.
           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
 
         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)
 
         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
 
     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):
         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)
           generate_pack_data: Function that can return a tuple
         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)
-        wants = determine_wants(refs)
+        wants = determine_wants(refs, depth=depth)
         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_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/contrib/test_swift_smoke.py b/dulwich/contrib/test_swift_smoke.py
index ac04a6bb..5cb540a9 100644
--- a/dulwich/contrib/test_swift_smoke.py
+++ b/dulwich/contrib/test_swift_smoke.py
@@ -1,313 +1,313 @@
 # test_smoke.py -- Functional tests for the Swift backend.
 # Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
 #
 # Author: Fabien Boucher <fabien.boucher@enovance.com>
 #
 # 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.
 #
 
 """Start functional tests
 
 A Swift installation must be available before
 starting those tests. The account and authentication method used
 during this functional tests must be changed in the configuration file
 passed as environment variable.
 The container used to create a fake repository is defined
 in cls.fakerepo and will be deleted after the tests.
 
 DULWICH_SWIFT_CFG=/tmp/conf.cfg PYTHONPATH=. python -m unittest \
     dulwich.tests_swift.test_smoke
 """
 
 import os
 import unittest
 import tempfile
 import shutil
 
 import gevent
 from gevent import monkey
 
 monkey.patch_all()
 
 from dulwich import (  # noqa:E402
     server,
     repo,
     index,
     client,
     objects,
 )
 from dulwich.contrib import swift  # noqa:E402
 
 
 class DulwichServer:
     """Start the TCPGitServer with Swift backend"""
 
     def __init__(self, backend, port):
         self.port = port
         self.backend = backend
 
     def run(self):
         self.server = server.TCPGitServer(self.backend, "localhost", port=self.port)
         self.job = gevent.spawn(self.server.serve_forever)
 
     def stop(self):
         self.server.shutdown()
         gevent.joinall((self.job,))
 
 
 class SwiftSystemBackend(server.Backend):
     def open_repository(self, path):
         return swift.SwiftRepo(path, conf=swift.load_conf())
 
 
 class SwiftRepoSmokeTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.backend = SwiftSystemBackend()
         cls.port = 9148
         cls.server_address = "localhost"
         cls.fakerepo = "fakerepo"
         cls.th_server = DulwichServer(cls.backend, cls.port)
         cls.th_server.run()
         cls.conf = swift.load_conf()
 
     @classmethod
     def tearDownClass(cls):
         cls.th_server.stop()
 
     def setUp(self):
         self.scon = swift.SwiftConnector(self.fakerepo, self.conf)
         if self.scon.test_root_exists():
             try:
                 self.scon.del_root()
             except swift.SwiftException:
                 pass
         self.temp_d = tempfile.mkdtemp()
         if os.path.isdir(self.temp_d):
             shutil.rmtree(self.temp_d)
 
     def tearDown(self):
         if self.scon.test_root_exists():
             try:
                 self.scon.del_root()
             except swift.SwiftException:
                 pass
         if os.path.isdir(self.temp_d):
             shutil.rmtree(self.temp_d)
 
     def test_init_bare(self):
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         self.assertTrue(self.scon.test_root_exists())
         obj = self.scon.get_container_objects()
         filtered = [
             o for o in obj if o["name"] == "info/refs" or o["name"] == "objects/pack"
         ]
         self.assertEqual(len(filtered), 2)
 
     def test_clone_bare(self):
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         remote_refs = tcp_client.fetch(self.fakerepo, local_repo)
         # The remote repo is empty (no refs retreived)
         self.assertEqual(remote_refs, None)
 
     def test_push_commit(self):
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {"refs/heads/master": local_repo.refs["HEAD"]}
 
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         # Nothing in the staging area
         local_repo.do_commit("Test commit", "fbo@localhost")
         sha = local_repo.refs.read_loose_ref("refs/heads/master")
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         tcp_client.send_pack(
             self.fakerepo, determine_wants, local_repo.generate_pack_data
         )
         swift_repo = swift.SwiftRepo("fakerepo", self.conf)
         remote_sha = swift_repo.refs.read_loose_ref("refs/heads/master")
         self.assertEqual(sha, remote_sha)
 
     def test_push_branch(self):
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {"refs/heads/mybranch": local_repo.refs["refs/heads/mybranch"]}
 
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         # Nothing in the staging area
         local_repo.do_commit("Test commit", "fbo@localhost", ref="refs/heads/mybranch")
         sha = local_repo.refs.read_loose_ref("refs/heads/mybranch")
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         tcp_client.send_pack(
             "/fakerepo", determine_wants, local_repo.generate_pack_data
         )
         swift_repo = swift.SwiftRepo(self.fakerepo, self.conf)
         remote_sha = swift_repo.refs.read_loose_ref("refs/heads/mybranch")
         self.assertEqual(sha, remote_sha)
 
     def test_push_multiple_branch(self):
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {
                 "refs/heads/mybranch": local_repo.refs["refs/heads/mybranch"],
                 "refs/heads/master": local_repo.refs["refs/heads/master"],
                 "refs/heads/pullr-108": local_repo.refs["refs/heads/pullr-108"],
             }
 
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         # Nothing in the staging area
         local_shas = {}
         remote_shas = {}
         for branch in ("master", "mybranch", "pullr-108"):
             local_shas[branch] = local_repo.do_commit(
                 "Test commit %s" % branch,
                 "fbo@localhost",
                 ref="refs/heads/%s" % branch,
             )
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         tcp_client.send_pack(
             self.fakerepo, determine_wants, local_repo.generate_pack_data
         )
         swift_repo = swift.SwiftRepo("fakerepo", self.conf)
         for branch in ("master", "mybranch", "pullr-108"):
             remote_shas[branch] = swift_repo.refs.read_loose_ref(
                 "refs/heads/%s" % branch
             )
         self.assertDictEqual(local_shas, remote_shas)
 
     def test_push_data_branch(self):
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {"refs/heads/master": local_repo.refs["HEAD"]}
 
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         os.mkdir(os.path.join(self.temp_d, "dir"))
         files = ("testfile", "testfile2", "dir/testfile3")
         i = 0
         for f in files:
             open(os.path.join(self.temp_d, f), "w").write("DATA %s" % i)
             i += 1
         local_repo.stage(files)
         local_repo.do_commit("Test commit", "fbo@localhost", ref="refs/heads/master")
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         tcp_client.send_pack(
             self.fakerepo, determine_wants, local_repo.generate_pack_data
         )
         swift_repo = swift.SwiftRepo("fakerepo", self.conf)
         commit_sha = swift_repo.refs.read_loose_ref("refs/heads/master")
         otype, data = swift_repo.object_store.get_raw(commit_sha)
         commit = objects.ShaFile.from_raw_string(otype, data)
         otype, data = swift_repo.object_store.get_raw(commit._tree)
         tree = objects.ShaFile.from_raw_string(otype, data)
         objs = tree.items()
         objs_ = []
         for tree_entry in objs:
             objs_.append(swift_repo.object_store.get_raw(tree_entry.sha))
         # Blob
         self.assertEqual(objs_[1][1], "DATA 0")
         self.assertEqual(objs_[2][1], "DATA 1")
         # Tree
         self.assertEqual(objs_[0][0], 2)
 
     def test_clone_then_push_data(self):
         self.test_push_data_branch()
         shutil.rmtree(self.temp_d)
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         remote_refs = tcp_client.fetch(self.fakerepo, local_repo)
         files = (
             os.path.join(self.temp_d, "testfile"),
             os.path.join(self.temp_d, "testfile2"),
         )
         local_repo["HEAD"] = remote_refs["refs/heads/master"]
         indexfile = local_repo.index_path()
         tree = local_repo["HEAD"].tree
         index.build_index_from_tree(
             local_repo.path, indexfile, local_repo.object_store, tree
         )
         for f in files:
             self.assertEqual(os.path.isfile(f), True)
 
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {"refs/heads/master": local_repo.refs["HEAD"]}
 
         os.mkdir(os.path.join(self.temp_d, "test"))
         files = ("testfile11", "testfile22", "test/testfile33")
         i = 0
         for f in files:
             open(os.path.join(self.temp_d, f), "w").write("DATA %s" % i)
             i += 1
         local_repo.stage(files)
         local_repo.do_commit("Test commit", "fbo@localhost", ref="refs/heads/master")
         tcp_client.send_pack(
             "/fakerepo", determine_wants, local_repo.generate_pack_data
         )
 
     def test_push_remove_branch(self):
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {
                 "refs/heads/pullr-108": objects.ZERO_SHA,
                 "refs/heads/master": local_repo.refs["refs/heads/master"],
                 "refs/heads/mybranch": local_repo.refs["refs/heads/mybranch"],
             }
 
         self.test_push_multiple_branch()
         local_repo = repo.Repo(self.temp_d)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         tcp_client.send_pack(
             self.fakerepo, determine_wants, local_repo.generate_pack_data
         )
         swift_repo = swift.SwiftRepo("fakerepo", self.conf)
         self.assertNotIn("refs/heads/pullr-108", swift_repo.refs.allkeys())
 
     def test_push_annotated_tag(self):
-        def determine_wants(*args):
+        def determine_wants(*args, **kwargs):
             return {
                 "refs/heads/master": local_repo.refs["HEAD"],
                 "refs/tags/v1.0": local_repo.refs["refs/tags/v1.0"],
             }
 
         local_repo = repo.Repo.init(self.temp_d, mkdir=True)
         # Nothing in the staging area
         sha = local_repo.do_commit("Test commit", "fbo@localhost")
         otype, data = local_repo.object_store.get_raw(sha)
         commit = objects.ShaFile.from_raw_string(otype, data)
         tag = objects.Tag()
         tag.tagger = "fbo@localhost"
         tag.message = "Annotated tag"
         tag.tag_timezone = objects.parse_timezone("-0200")[0]
         tag.tag_time = commit.author_time
         tag.object = (objects.Commit, commit.id)
         tag.name = "v0.1"
         local_repo.object_store.add_object(tag)
         local_repo.refs["refs/tags/v1.0"] = tag.id
         swift.SwiftRepo.init_bare(self.scon, self.conf)
         tcp_client = client.TCPGitClient(self.server_address, port=self.port)
         tcp_client.send_pack(
             self.fakerepo, determine_wants, local_repo.generate_pack_data
         )
         swift_repo = swift.SwiftRepo(self.fakerepo, self.conf)
         tag_sha = swift_repo.refs.read_loose_ref("refs/tags/v1.0")
         otype, data = swift_repo.object_store.get_raw(tag_sha)
         rtag = objects.ShaFile.from_raw_string(otype, data)
         self.assertEqual(rtag.object[1], commit.id)
         self.assertEqual(rtag.id, tag.id)
 
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/dulwich/object_store.py b/dulwich/object_store.py
index a5d07e09..99c81638 100644
--- a/dulwich/object_store.py
+++ b/dulwich/object_store.py
@@ -1,1556 +1,1597 @@
 # 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"
 
 
 class BaseObjectStore(object):
     """Object store interface."""
 
-    def determine_wants_all(self, refs):
+    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
+            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")
         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:
             indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
             copier = PackStreamCopier(read_all, read_some, f, delta_iter=indexer)
             copier.verify()
             return self._complete_thin_pack(f, path, copier, indexer)
 
     def move_in_pack(self, path):
         """Move a specific file containing a pack into the pack directory.
 
         Note: The file should be on the same file system as the
             packs directory.
 
         Args:
           path: Path to the pack file.
         """
         with PackData(path) as p:
             entries = p.sorted_entries()
             basename = self._get_pack_basepath(entries)
             index_name = basename + ".idx"
             if not os.path.exists(index_name):
                 with GitFile(index_name, "wb") as f:
                     write_pack_index_v2(f, entries, p.get_stored_checksum())
         for pack in self.packs:
             if pack._basename == basename:
                 return pack
         target_pack = basename + ".pack"
         if sys.platform == "win32":
             # Windows might have the target pack file lingering. Attempt
             # removal, silently passing if the target does not exist.
             try:
                 os.remove(target_pack)
             except FileNotFoundError:
                 pass
         os.rename(path, target_pack)
         final_pack = Pack(basename)
         self._add_cached_pack(basename, final_pack)
         return final_pack
 
     def add_pack(self):
         """Add a new pack to this object store.
 
         Returns: Fileobject to write to, a commit function to
             call when the pack is finished and an abort
             function.
         """
         import tempfile
 
         fd, path = tempfile.mkstemp(dir=self.pack_dir, suffix=".pack")
         f = os.fdopen(fd, "wb")
 
         def commit():
             f.flush()
             os.fsync(fd)
             f.close()
             if os.path.getsize(path) > 0:
                 return self.move_in_pack(path)
             else:
                 os.remove(path)
                 return None
 
         def abort():
             f.close()
             os.remove(path)
 
         return f, commit, abort
 
     def add_object(self, obj):
         """Add a single object to this object store.
 
         Args:
           obj: Object to add
         """
         path = self._get_shafile_path(obj.id)
         dir = os.path.dirname(path)
         try:
             os.mkdir(dir)
         except FileExistsError:
             pass
         if os.path.exists(path):
             return  # Already there, no need to write again
         with GitFile(path, "wb") as f:
             f.write(
                 obj.as_legacy_object(compression_level=self.loose_compression_level)
             )
 
     @classmethod
     def init(cls, path):
         try:
             os.mkdir(path)
         except FileExistsError:
             pass
         os.mkdir(os.path.join(path, "info"))
         os.mkdir(os.path.join(path, PACKDIR))
         return cls(path)
 
 
 class MemoryObjectStore(BaseObjectStore):
     """Object store that keeps all objects in memory."""
 
     def __init__(self):
         super(MemoryObjectStore, self).__init__()
         self._data = {}
         self.pack_compression_level = -1
 
     def _to_hexsha(self, sha):
         if len(sha) == 40:
             return sha
         elif len(sha) == 20:
             return sha_to_hex(sha)
         else:
             raise ValueError("Invalid sha %r" % (sha,))
 
     def contains_loose(self, sha):
         """Check if a particular object is present by SHA1 and is loose."""
         return self._to_hexsha(sha) in self._data
 
     def contains_packed(self, sha):
         """Check if a particular object is present by SHA1 and is packed."""
         return False
 
     def __iter__(self):
         """Iterate over the SHAs that are present in this store."""
         return iter(self._data.keys())
 
     @property
     def packs(self):
         """List with pack objects."""
         return []
 
     def get_raw(self, name):
         """Obtain the raw text for an object.
 
         Args:
           name: sha for the object.
         Returns: tuple with numeric type and object contents.
         """
         obj = self[self._to_hexsha(name)]
         return obj.type_num, obj.as_raw_string()
 
     def __getitem__(self, name):
         return self._data[self._to_hexsha(name)].copy()
 
     def __delitem__(self, name):
         """Delete an object from this store, for testing only."""
         del self._data[self._to_hexsha(name)]
 
     def add_object(self, obj):
         """Add a single object to this object store."""
         self._data[obj.id] = obj.copy()
 
     def add_objects(self, objects, progress=None):
         """Add a set of objects to this object store.
 
         Args:
           objects: Iterable over a list of (object, path) tuples
         """
         for obj, path in objects:
             self.add_object(obj)
 
     def add_pack(self):
         """Add a new pack to this object store.
 
         Because this object store doesn't support packs, we extract and add the
         individual objects.
 
         Returns: Fileobject to write to and a commit function to
             call when the pack is finished.
         """
         f = BytesIO()
 
         def commit():
             p = PackData.from_file(BytesIO(f.getvalue()), f.tell())
             f.close()
             for obj in PackInflater.for_pack_data(p, self.get_raw):
                 self.add_object(obj)
 
         def abort():
             pass
 
         return f, commit, abort
 
     def _complete_thin_pack(self, f, indexer):
         """Complete a thin pack by adding external references.
 
         Args:
           f: Open file object for the pack.
           indexer: A PackIndexer for indexing the pack.
         """
         entries = list(indexer)
 
         # Update the header with the new number of objects.
         f.seek(0)
         write_pack_header(f, len(entries) + len(indexer.ext_refs()))
 
         # Rescan the rest of the pack, computing the SHA with the new header.
         new_sha = compute_file_sha(f, end_ofs=-20)
 
         # Complete the pack.
         for ext_sha in indexer.ext_refs():
             assert len(ext_sha) == 20
             type_num, data = self.get_raw(ext_sha)
             write_pack_object(f, type_num, data, sha=new_sha)
         pack_sha = new_sha.digest()
         f.write(pack_sha)
 
     def add_thin_pack(self, read_all, read_some):
         """Add a new thin pack to this object store.
 
         Thin packs are packs that contain deltas with parents that exist
         outside the pack. Because this object store doesn't support packs, we
         extract and add the individual objects.
 
         Args:
           read_all: Read function that blocks until the number of
             requested bytes are read.
           read_some: Read function that returns at least one byte, but may
             not return the number of bytes requested.
         """
         f, commit, abort = self.add_pack()
         try:
             indexer = PackIndexer(f, resolve_ext_ref=self.get_raw)
             copier = PackStreamCopier(read_all, read_some, f, delta_iter=indexer)
             copier.verify()
             self._complete_thin_pack(f, indexer)
         except BaseException:
             abort()
             raise
         else:
             commit()
 
 
 class ObjectIterator(object):
     """Interface for iterating over objects."""
 
     def iterobjects(self):
         raise NotImplementedError(self.iterobjects)
 
 
 class ObjectStoreIterator(ObjectIterator):
     """ObjectIterator that works on top of an ObjectStore."""
 
     def __init__(self, store, sha_iter):
         """Create a new ObjectIterator.
 
         Args:
           store: Object store to retrieve from
           sha_iter: Iterator over (sha, path) tuples
         """
         self.store = store
         self.sha_iter = sha_iter
         self._shas = []
 
     def __iter__(self):
         """Yield tuple with next object and path."""
         for sha, path in self.itershas():
             yield self.store[sha], path
 
     def iterobjects(self):
         """Iterate over just the objects."""
         for o, path in self:
             yield o
 
     def itershas(self):
         """Iterate over the SHAs."""
         for sha in self._shas:
             yield sha
         for sha in self.sha_iter:
             self._shas.append(sha)
             yield sha
 
     def __contains__(self, needle):
         """Check if an object is present.
 
         Note: This checks if the object is present in
             the underlying object store, not if it would
             be yielded by the iterator.
 
         Args:
           needle: SHA1 of the object to check for
         """
         if needle == ZERO_SHA:
             return False
         return needle in self.store
 
     def __getitem__(self, key):
         """Find an object by SHA1.
 
         Note: This retrieves the object from the underlying
             object store. It will also succeed if the object would
             not be returned by the iterator.
         """
         return self.store[key]
 
     def __len__(self):
         """Return the number of objects."""
         return len(list(self.itershas()))
 
     def empty(self):
         import warnings
 
         warnings.warn("Use bool() instead.", DeprecationWarning)
         return self._empty()
 
     def _empty(self):
         it = self.itershas()
         try:
             next(it)
         except StopIteration:
             return True
         else:
             return False
 
     def __bool__(self):
         """Indicate whether this object has contents."""
         return not self._empty()
 
 
 def tree_lookup_path(lookup_obj, root_sha, path):
     """Look up an object in a Git tree.
 
     Args:
       lookup_obj: Callback for retrieving object by SHA1
       root_sha: SHA1 of the root tree
       path: Path to lookup
     Returns: A tuple of (mode, SHA) of the resulting path.
     """
     tree = lookup_obj(root_sha)
     if not isinstance(tree, Tree):
         raise NotTreeError(root_sha)
     return tree.lookup_path(lookup_obj, path)
 
 
 def _collect_filetree_revs(obj_store, tree_sha, kset):
     """Collect SHA1s of files and directories for specified tree.
 
     Args:
       obj_store: Object store to get objects by SHA from
       tree_sha: tree reference to walk
       kset: set to fill with references to files and directories
     """
     filetree = obj_store[tree_sha]
     for name, mode, sha in filetree.iteritems():
         if not S_ISGITLINK(mode) and sha not in kset:
             kset.add(sha)
             if stat.S_ISDIR(mode):
                 _collect_filetree_revs(obj_store, sha, kset)
 
 
 def _split_commits_and_tags(obj_store, lst, ignore_unknown=False):
     """Split object id list into three lists with commit, tag, and other SHAs.
 
     Commits referenced by tags are included into commits
     list as well. Only SHA1s known in this repository will get
     through, and unless ignore_unknown argument is True, KeyError
     is thrown for SHA1 missing in the repository
 
     Args:
       obj_store: Object store to get objects by SHA1 from
       lst: Collection of commit and tag SHAs
       ignore_unknown: True to skip SHA1 missing in the repository
         silently.
     Returns: A tuple of (commits, tags, others) SHA1s
     """
     commits = set()
     tags = set()
     others = set()
     for e in lst:
         try:
             o = obj_store[e]
         except KeyError:
             if not ignore_unknown:
                 raise
         else:
             if isinstance(o, Commit):
                 commits.add(e)
             elif isinstance(o, Tag):
                 tags.add(e)
                 tagged = o.object[1]
                 c, t, o = _split_commits_and_tags(
                     obj_store, [tagged], ignore_unknown=ignore_unknown
                 )
                 commits |= c
                 tags |= t
                 others |= o
             else:
                 others.add(e)
     return (commits, tags, others)
 
 
 class MissingObjectFinder(object):
     """Find the objects missing from another object store.
 
     Args:
       object_store: Object store containing at least all objects to be
         sent
       haves: SHA1s of commits not to send (already present in target)
       wants: SHA1s of commits to send
       progress: Optional function to report progress to.
       get_tagged: Function that returns a dict of pointed-to sha -> tag
         sha for including tags.
       get_parents: Optional function for getting the parents of a commit.
       tagged: dict of pointed-to sha -> tag sha for including tags
     """
 
     def __init__(
         self,
         object_store,
         haves,
         wants,
         shallow=None,
         progress=None,
         get_tagged=None,
         get_parents=lambda commit: commit.parents,
     ):
         self.object_store = object_store
         if shallow is None:
             shallow = set()
         self._get_parents = get_parents
         # process Commits and Tags differently
         # Note, while haves may list commits/tags not available locally,
         # and such SHAs would get filtered out by _split_commits_and_tags,
         # wants shall list only known SHAs, and otherwise
         # _split_commits_and_tags fails with KeyError
         have_commits, have_tags, have_others = _split_commits_and_tags(
             object_store, haves, True
         )
         want_commits, want_tags, want_others = _split_commits_and_tags(
             object_store, wants, False
         )
         # all_ancestors is a set of commits that shall not be sent
         # (complete repository up to 'haves')
         all_ancestors = object_store._collect_ancestors(
             have_commits, shallow=shallow, get_parents=self._get_parents
         )[0]
         # all_missing - complete set of commits between haves and wants
         # common - commits from all_ancestors we hit into while
         # traversing parent hierarchy of wants
         missing_commits, common_commits = object_store._collect_ancestors(
             want_commits,
             all_ancestors,
             shallow=shallow,
             get_parents=self._get_parents,
         )
         self.sha_done = set()
         # Now, fill sha_done with commits and revisions of
         # files and directories known to be both locally
         # and on target. Thus these commits and files
         # won't get selected for fetch
         for h in common_commits:
             self.sha_done.add(h)
             cmt = object_store[h]
             _collect_filetree_revs(object_store, cmt.tree, self.sha_done)
         # record tags we have as visited, too
         for t in have_tags:
             self.sha_done.add(t)
 
         missing_tags = want_tags.difference(have_tags)
         missing_others = want_others.difference(have_others)
         # in fact, what we 'want' is commits, tags, and others
         # we've found missing
         wants = missing_commits.union(missing_tags)
         wants = wants.union(missing_others)
 
         self.objects_to_send = set([(w, None, False) for w in wants])
 
         if progress is None:
             self.progress = lambda x: None
         else:
             self.progress = progress
         self._tagged = get_tagged and get_tagged() or {}
 
     def add_todo(self, entries):
         self.objects_to_send.update([e for e in entries if not e[0] in self.sha_done])
 
     def next(self):
         while True:
             if not self.objects_to_send:
                 return None
             (sha, name, leaf) = self.objects_to_send.pop()
             if sha not in self.sha_done:
                 break
         if not leaf:
             o = self.object_store[sha]
             if isinstance(o, Commit):
                 self.add_todo([(o.tree, "", False)])
             elif isinstance(o, Tree):
                 self.add_todo(
                     [
                         (s, n, not stat.S_ISDIR(m))
                         for n, m, s in o.iteritems()
                         if not S_ISGITLINK(m)
                     ]
                 )
             elif isinstance(o, Tag):
                 self.add_todo([(o.object[1], None, False)])
         if sha in self._tagged:
             self.add_todo([(self._tagged[sha], None, True)])
         self.sha_done.add(sha)
         self.progress(("counting objects: %d\r" % len(self.sha_done)).encode("ascii"))
         return (sha, name)
 
     __next__ = next
 
 
 class ObjectStoreGraphWalker(object):
     """Graph walker that finds what commits are missing from an object store.
 
     :ivar heads: Revisions without descendants in the local repo
     :ivar get_parents: Function to retrieve parents in the local repo
     """
 
     def __init__(self, local_heads, get_parents, shallow=None):
         """Create a new instance.
 
         Args:
           local_heads: Heads to start search with
           get_parents: Function for finding the parents of a SHA1.
         """
         self.heads = set(local_heads)
         self.get_parents = get_parents
         self.parents = {}
         if shallow is None:
             shallow = set()
         self.shallow = shallow
 
     def ack(self, sha):
         """Ack that a revision and its ancestors are present in the source."""
         if len(sha) != 40:
             raise ValueError("unexpected sha %r received" % sha)
         ancestors = set([sha])
 
         # stop if we run out of heads to remove
         while self.heads:
             for a in ancestors:
                 if a in self.heads:
                     self.heads.remove(a)
 
             # collect all ancestors
             new_ancestors = set()
             for a in ancestors:
                 ps = self.parents.get(a)
                 if ps is not None:
                     new_ancestors.update(ps)
                 self.parents[a] = None
 
             # no more ancestors; stop
             if not new_ancestors:
                 break
 
             ancestors = new_ancestors
 
     def next(self):
         """Iterate over ancestors of heads in the target."""
         if self.heads:
             ret = self.heads.pop()
-            ps = self.get_parents(ret)
+            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 3fcae712..08fa288f 100644
--- a/dulwich/porcelain.py
+++ b/dulwich/porcelain.py
@@ -1,1890 +1,1890 @@
 # 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
     """
     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:
             relpath = str(Path(p).resolve().relative_to(repo_path))
             # FIXME: Support patterns, directories.
             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) + "\n")
     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
     """
 
     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
             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:
                 import gpg
 
                 with gpg.Context(armor=True) as c:
                     tag_obj.signature, unused_result = c.sign(tag_obj.as_raw_string())
             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):
+        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):
     """Get path, is_dir for files in working dir from frompath
 
     Args:
       frompath: Path to begin walk
       basepath: Path to compare to
     """
     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
 
 
 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
     """
     if exclude_ignored:
         with open_repo_closing(frompath) as r:
             ignore_manager = IgnoreFilterManager.from_repo(r)
     else:
         ignore_manager = None
 
     for ap, is_dir in _walk_working_dir_paths(frompath, basepath):
         if ignore_manager is not None and ignore_manager.is_ignored(
             os.path.relpath(ap, frompath)
         ):
             continue
         if not is_dir:
             ip = path_to_tree_path(basepath, ap)
             if ip not in index:
                 yield os.path.relpath(ap, frompath)
 
 
 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."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
         stash.pop()
 
 
 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/protocol.py b/dulwich/protocol.py
index 9641d06f..553e9cd0 100644
--- a/dulwich/protocol.py
+++ b/dulwich/protocol.py
@@ -1,583 +1,585 @@
 # protocol.py -- Shared parts of the git protocols
 # Copyright (C) 2008 John Carr <john.carr@unrouted.co.uk>
 # Copyright (C) 2008-2012 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.
 #
 
 """Generic functions for talking the git smart server protocol."""
 
 from io import BytesIO
 from os import (
     SEEK_END,
 )
 import socket
 
 import dulwich
 from dulwich.errors import (
     HangupException,
     GitProtocolError,
 )
 
 TCP_GIT_PORT = 9418
 
 ZERO_SHA = b"0" * 40
 
 SINGLE_ACK = 0
 MULTI_ACK = 1
 MULTI_ACK_DETAILED = 2
 
 # pack data
 SIDE_BAND_CHANNEL_DATA = 1
 # progress messages
 SIDE_BAND_CHANNEL_PROGRESS = 2
 # fatal error message just before stream aborts
 SIDE_BAND_CHANNEL_FATAL = 3
 
 CAPABILITY_ATOMIC = b"atomic"
 CAPABILITY_DEEPEN_SINCE = b"deepen-since"
 CAPABILITY_DEEPEN_NOT = b"deepen-not"
 CAPABILITY_DEEPEN_RELATIVE = b"deepen-relative"
 CAPABILITY_DELETE_REFS = b"delete-refs"
 CAPABILITY_INCLUDE_TAG = b"include-tag"
 CAPABILITY_MULTI_ACK = b"multi_ack"
 CAPABILITY_MULTI_ACK_DETAILED = b"multi_ack_detailed"
 CAPABILITY_NO_DONE = b"no-done"
 CAPABILITY_NO_PROGRESS = b"no-progress"
 CAPABILITY_OFS_DELTA = b"ofs-delta"
 CAPABILITY_QUIET = b"quiet"
 CAPABILITY_REPORT_STATUS = b"report-status"
 CAPABILITY_SHALLOW = b"shallow"
 CAPABILITY_SIDE_BAND = b"side-band"
 CAPABILITY_SIDE_BAND_64K = b"side-band-64k"
 CAPABILITY_THIN_PACK = b"thin-pack"
 CAPABILITY_AGENT = b"agent"
 CAPABILITY_SYMREF = b"symref"
 CAPABILITY_ALLOW_TIP_SHA1_IN_WANT = b"allow-tip-sha1-in-want"
 CAPABILITY_ALLOW_REACHABLE_SHA1_IN_WANT = b"allow-reachable-sha1-in-want"
 
 # Magic ref that is used to attach capabilities to when
 # there are no refs. Should always be ste to ZERO_SHA.
 CAPABILITIES_REF = b"capabilities^{}"
 
 COMMON_CAPABILITIES = [
     CAPABILITY_OFS_DELTA,
     CAPABILITY_SIDE_BAND,
     CAPABILITY_SIDE_BAND_64K,
     CAPABILITY_AGENT,
     CAPABILITY_NO_PROGRESS,
 ]
 KNOWN_UPLOAD_CAPABILITIES = set(
     COMMON_CAPABILITIES
     + [
         CAPABILITY_THIN_PACK,
         CAPABILITY_MULTI_ACK,
         CAPABILITY_MULTI_ACK_DETAILED,
         CAPABILITY_INCLUDE_TAG,
         CAPABILITY_DEEPEN_SINCE,
         CAPABILITY_SYMREF,
         CAPABILITY_SHALLOW,
         CAPABILITY_DEEPEN_NOT,
         CAPABILITY_DEEPEN_RELATIVE,
         CAPABILITY_ALLOW_TIP_SHA1_IN_WANT,
         CAPABILITY_ALLOW_REACHABLE_SHA1_IN_WANT,
     ]
 )
 KNOWN_RECEIVE_CAPABILITIES = set(
     COMMON_CAPABILITIES
     + [
         CAPABILITY_REPORT_STATUS,
         CAPABILITY_DELETE_REFS,
         CAPABILITY_QUIET,
         CAPABILITY_ATOMIC,
     ]
 )
 
+DEPTH_INFINITE = 0x7FFFFFFF
+
 
 def agent_string():
     return ("dulwich/%d.%d.%d" % dulwich.__version__).encode("ascii")
 
 
 def capability_agent():
     return CAPABILITY_AGENT + b"=" + agent_string()
 
 
 def capability_symref(from_ref, to_ref):
     return CAPABILITY_SYMREF + b"=" + from_ref + b":" + to_ref
 
 
 def extract_capability_names(capabilities):
     return {parse_capability(c)[0] for c in capabilities}
 
 
 def parse_capability(capability):
     parts = capability.split(b"=", 1)
     if len(parts) == 1:
         return (parts[0], None)
     return tuple(parts)
 
 
 def symref_capabilities(symrefs):
     return [capability_symref(*k) for k in symrefs]
 
 
 COMMAND_DEEPEN = b"deepen"
 COMMAND_SHALLOW = b"shallow"
 COMMAND_UNSHALLOW = b"unshallow"
 COMMAND_DONE = b"done"
 COMMAND_WANT = b"want"
 COMMAND_HAVE = b"have"
 
 
 class ProtocolFile(object):
     """A dummy file for network ops that expect file-like objects."""
 
     def __init__(self, read, write):
         self.read = read
         self.write = write
 
     def tell(self):
         pass
 
     def close(self):
         pass
 
 
 def format_cmd_pkt(cmd, *args):
     return cmd + b" " + b"".join([(a + b"\0") for a in args])
 
 
 def parse_cmd_pkt(line):
     splice_at = line.find(b" ")
     cmd, args = line[:splice_at], line[splice_at + 1 :]
     assert args[-1:] == b"\x00"
     return cmd, args[:-1].split(b"\0")
 
 
 def pkt_line(data):
     """Wrap data in a pkt-line.
 
     Args:
       data: The data to wrap, as a str or None.
     Returns: The data prefixed with its length in pkt-line format; if data was
         None, returns the flush-pkt ('0000').
     """
     if data is None:
         return b"0000"
     return ("%04x" % (len(data) + 4)).encode("ascii") + data
 
 
 class Protocol(object):
     """Class for interacting with a remote git process over the wire.
 
     Parts of the git wire protocol use 'pkt-lines' to communicate. A pkt-line
     consists of the length of the line as a 4-byte hex string, followed by the
     payload data. The length includes the 4-byte header. The special line
     '0000' indicates the end of a section of input and is called a 'flush-pkt'.
 
     For details on the pkt-line format, see the cgit distribution:
         Documentation/technical/protocol-common.txt
     """
 
     def __init__(self, read, write, close=None, report_activity=None):
         self.read = read
         self.write = write
         self._close = close
         self.report_activity = report_activity
         self._readahead = None
 
     def close(self):
         if self._close:
             self._close()
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
     def read_pkt_line(self):
         """Reads a pkt-line from the remote git process.
 
         This method may read from the readahead buffer; see unread_pkt_line.
 
         Returns: The next string from the stream, without the length prefix, or
             None for a flush-pkt ('0000').
         """
         if self._readahead is None:
             read = self.read
         else:
             read = self._readahead.read
             self._readahead = None
 
         try:
             sizestr = read(4)
             if not sizestr:
                 raise HangupException()
             size = int(sizestr, 16)
             if size == 0:
                 if self.report_activity:
                     self.report_activity(4, "read")
                 return None
             if self.report_activity:
                 self.report_activity(size, "read")
             pkt_contents = read(size - 4)
         except socket.error as e:
             raise GitProtocolError(e)
         else:
             if len(pkt_contents) + 4 != size:
                 raise GitProtocolError(
                     "Length of pkt read %04x does not match length prefix %04x"
                     % (len(pkt_contents) + 4, size)
                 )
             return pkt_contents
 
     def eof(self):
         """Test whether the protocol stream has reached EOF.
 
         Note that this refers to the actual stream EOF and not just a
         flush-pkt.
 
         Returns: True if the stream is at EOF, False otherwise.
         """
         try:
             next_line = self.read_pkt_line()
         except HangupException:
             return True
         self.unread_pkt_line(next_line)
         return False
 
     def unread_pkt_line(self, data):
         """Unread a single line of data into the readahead buffer.
 
         This method can be used to unread a single pkt-line into a fixed
         readahead buffer.
 
         Args:
           data: The data to unread, without the length prefix.
         Raises:
           ValueError: If more than one pkt-line is unread.
         """
         if self._readahead is not None:
             raise ValueError("Attempted to unread multiple pkt-lines.")
         self._readahead = BytesIO(pkt_line(data))
 
     def read_pkt_seq(self):
         """Read a sequence of pkt-lines from the remote git process.
 
         Returns: Yields each line of data up to but not including the next
             flush-pkt.
         """
         pkt = self.read_pkt_line()
         while pkt:
             yield pkt
             pkt = self.read_pkt_line()
 
     def write_pkt_line(self, line):
         """Sends a pkt-line to the remote git process.
 
         Args:
           line: A string containing the data to send, without the length
             prefix.
         """
         try:
             line = pkt_line(line)
             self.write(line)
             if self.report_activity:
                 self.report_activity(len(line), "write")
         except socket.error as e:
             raise GitProtocolError(e)
 
     def write_file(self):
         """Return a writable file-like object for this protocol."""
 
         class ProtocolFile(object):
             def __init__(self, proto):
                 self._proto = proto
                 self._offset = 0
 
             def write(self, data):
                 self._proto.write(data)
                 self._offset += len(data)
 
             def tell(self):
                 return self._offset
 
             def close(self):
                 pass
 
         return ProtocolFile(self)
 
     def write_sideband(self, channel, blob):
         """Write multiplexed data to the sideband.
 
         Args:
           channel: An int specifying the channel to write to.
           blob: A blob of data (as a string) to send on this channel.
         """
         # a pktline can be a max of 65520. a sideband line can therefore be
         # 65520-5 = 65515
         # WTF: Why have the len in ASCII, but the channel in binary.
         while blob:
             self.write_pkt_line(bytes(bytearray([channel])) + blob[:65515])
             blob = blob[65515:]
 
     def send_cmd(self, cmd, *args):
         """Send a command and some arguments to a git server.
 
         Only used for the TCP git protocol (git://).
 
         Args:
           cmd: The remote service to access.
           args: List of arguments to send to remove service.
         """
         self.write_pkt_line(format_cmd_pkt(cmd, *args))
 
     def read_cmd(self):
         """Read a command and some arguments from the git client
 
         Only used for the TCP git protocol (git://).
 
         Returns: A tuple of (command, [list of arguments]).
         """
         line = self.read_pkt_line()
         return parse_cmd_pkt(line)
 
 
 _RBUFSIZE = 8192  # Default read buffer size.
 
 
 class ReceivableProtocol(Protocol):
     """Variant of Protocol that allows reading up to a size without blocking.
 
     This class has a recv() method that behaves like socket.recv() in addition
     to a read() method.
 
     If you want to read n bytes from the wire and block until exactly n bytes
     (or EOF) are read, use read(n). If you want to read at most n bytes from
     the wire but don't care if you get less, use recv(n). Note that recv(n)
     will still block until at least one byte is read.
     """
 
     def __init__(
         self, recv, write, close=None, report_activity=None, rbufsize=_RBUFSIZE
     ):
         super(ReceivableProtocol, self).__init__(
             self.read, write, close=close, report_activity=report_activity
         )
         self._recv = recv
         self._rbuf = BytesIO()
         self._rbufsize = rbufsize
 
     def read(self, size):
         # From _fileobj.read in socket.py in the Python 2.6.5 standard library,
         # with the following modifications:
         #  - omit the size <= 0 branch
         #  - seek back to start rather than 0 in case some buffer has been
         #    consumed.
         #  - use SEEK_END instead of the magic number.
         # Copyright (c) 2001-2010 Python Software Foundation; All Rights
         # Reserved
         # Licensed under the Python Software Foundation License.
         # TODO: see if buffer is more efficient than cBytesIO.
         assert size > 0
 
         # Our use of BytesIO rather than lists of string objects returned by
         # recv() minimizes memory usage and fragmentation that occurs when
         # rbufsize is large compared to the typical return value of recv().
         buf = self._rbuf
         start = buf.tell()
         buf.seek(0, SEEK_END)
         # buffer may have been partially consumed by recv()
         buf_len = buf.tell() - start
         if buf_len >= size:
             # Already have size bytes in our buffer?  Extract and return.
             buf.seek(start)
             rv = buf.read(size)
             self._rbuf = BytesIO()
             self._rbuf.write(buf.read())
             self._rbuf.seek(0)
             return rv
 
         self._rbuf = BytesIO()  # reset _rbuf.  we consume it via buf.
         while True:
             left = size - buf_len
             # recv() will malloc the amount of memory given as its
             # parameter even though it often returns much less data
             # than that.  The returned data string is short lived
             # as we copy it into a BytesIO and free it.  This avoids
             # fragmentation issues on many platforms.
             data = self._recv(left)
             if not data:
                 break
             n = len(data)
             if n == size and not buf_len:
                 # Shortcut.  Avoid buffer data copies when:
                 # - We have no data in our buffer.
                 # AND
                 # - Our call to recv returned exactly the
                 #   number of bytes we were asked to read.
                 return data
             if n == left:
                 buf.write(data)
                 del data  # explicit free
                 break
             assert n <= left, "_recv(%d) returned %d bytes" % (left, n)
             buf.write(data)
             buf_len += n
             del data  # explicit free
             # assert buf_len == buf.tell()
         buf.seek(start)
         return buf.read()
 
     def recv(self, size):
         assert size > 0
 
         buf = self._rbuf
         start = buf.tell()
         buf.seek(0, SEEK_END)
         buf_len = buf.tell()
         buf.seek(start)
 
         left = buf_len - start
         if not left:
             # only read from the wire if our read buffer is exhausted
             data = self._recv(self._rbufsize)
             if len(data) == size:
                 # shortcut: skip the buffer if we read exactly size bytes
                 return data
             buf = BytesIO()
             buf.write(data)
             buf.seek(0)
             del data  # explicit free
             self._rbuf = buf
         return buf.read(size)
 
 
 def extract_capabilities(text):
     """Extract a capabilities list from a string, if present.
 
     Args:
       text: String to extract from
     Returns: Tuple with text with capabilities removed and list of capabilities
     """
     if b"\0" not in text:
         return text, []
     text, capabilities = text.rstrip().split(b"\0")
     return (text, capabilities.strip().split(b" "))
 
 
 def extract_want_line_capabilities(text):
     """Extract a capabilities list from a want line, if present.
 
     Note that want lines have capabilities separated from the rest of the line
     by a space instead of a null byte. Thus want lines have the form:
 
         want obj-id cap1 cap2 ...
 
     Args:
       text: Want line to extract from
     Returns: Tuple with text with capabilities removed and list of capabilities
     """
     split_text = text.rstrip().split(b" ")
     if len(split_text) < 3:
         return text, []
     return (b" ".join(split_text[:2]), split_text[2:])
 
 
 def ack_type(capabilities):
     """Extract the ack type from a capabilities list."""
     if b"multi_ack_detailed" in capabilities:
         return MULTI_ACK_DETAILED
     elif b"multi_ack" in capabilities:
         return MULTI_ACK
     return SINGLE_ACK
 
 
 class BufferedPktLineWriter(object):
     """Writer that wraps its data in pkt-lines and has an independent buffer.
 
     Consecutive calls to write() wrap the data in a pkt-line and then buffers
     it until enough lines have been written such that their total length
     (including length prefix) reach the buffer size.
     """
 
     def __init__(self, write, bufsize=65515):
         """Initialize the BufferedPktLineWriter.
 
         Args:
           write: A write callback for the underlying writer.
           bufsize: The internal buffer size, including length prefixes.
         """
         self._write = write
         self._bufsize = bufsize
         self._wbuf = BytesIO()
         self._buflen = 0
 
     def write(self, data):
         """Write data, wrapping it in a pkt-line."""
         line = pkt_line(data)
         line_len = len(line)
         over = self._buflen + line_len - self._bufsize
         if over >= 0:
             start = line_len - over
             self._wbuf.write(line[:start])
             self.flush()
         else:
             start = 0
         saved = line[start:]
         self._wbuf.write(saved)
         self._buflen += len(saved)
 
     def flush(self):
         """Flush all data from the buffer."""
         data = self._wbuf.getvalue()
         if data:
             self._write(data)
         self._len = 0
         self._wbuf = BytesIO()
 
 
 class PktLineParser(object):
     """Packet line parser that hands completed packets off to a callback."""
 
     def __init__(self, handle_pkt):
         self.handle_pkt = handle_pkt
         self._readahead = BytesIO()
 
     def parse(self, data):
         """Parse a fragment of data and call back for any completed packets."""
         self._readahead.write(data)
         buf = self._readahead.getvalue()
         if len(buf) < 4:
             return
         while len(buf) >= 4:
             size = int(buf[:4], 16)
             if size == 0:
                 self.handle_pkt(None)
                 buf = buf[4:]
             elif size <= len(buf):
                 self.handle_pkt(buf[4:size])
                 buf = buf[size:]
             else:
                 break
         self._readahead = BytesIO()
         self._readahead.write(buf)
 
     def get_tail(self):
         """Read back any unused data."""
         return self._readahead.getvalue()
diff --git a/dulwich/repo.py b/dulwich/repo.py
index dd73738b..bfe72c33 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,1629 +1,1634 @@
 # 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
 
 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)
+        wants = determine_wants(refs, depth=depth)
         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)
-        self._put_named_file("shallow", b"".join([sha + b"\n" for sha in shallow]))
+        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):
             fs_paths = [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 = {}
         return BlobNormalizer(self.get_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/server.py b/dulwich/server.py
index 0cff125d..7e8da3c9 100644
--- a/dulwich/server.py
+++ b/dulwich/server.py
@@ -1,1278 +1,1278 @@
 # server.py -- Implementation of the server side git protocols
 # Copyright (C) 2008 John Carr <john.carr@unrouted.co.uk>
 # Coprygith (C) 2011-2012 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.
 #
 
 """Git smart network protocol server implementation.
 
 For more detailed implementation on the network protocol, see the
 Documentation/technical directory in the cgit distribution, and in particular:
 
 * Documentation/technical/protocol-capabilities.txt
 * Documentation/technical/pack-protocol.txt
 
 Currently supported capabilities:
 
  * include-tag
  * thin-pack
  * multi_ack_detailed
  * multi_ack
  * side-band-64k
  * ofs-delta
  * no-progress
  * report-status
  * delete-refs
  * shallow
  * symref
 """
 
 import collections
 import os
 import socket
 import sys
 import time
 from typing import List, Tuple, Dict, Optional, Iterable
 import zlib
 
 import socketserver
 
 from dulwich.archive import tar_stream
 from dulwich.errors import (
     ApplyDeltaError,
     ChecksumMismatch,
     GitProtocolError,
     HookError,
     NotGitRepository,
     UnexpectedCommandError,
     ObjectFormatException,
 )
 from dulwich import log_utils
 from dulwich.objects import (
     Commit,
     valid_hexsha,
 )
 from dulwich.pack import (
     write_pack_objects,
 )
 from dulwich.protocol import (  # noqa: F401
     BufferedPktLineWriter,
     capability_agent,
     CAPABILITIES_REF,
     CAPABILITY_AGENT,
     CAPABILITY_DELETE_REFS,
     CAPABILITY_INCLUDE_TAG,
     CAPABILITY_MULTI_ACK_DETAILED,
     CAPABILITY_MULTI_ACK,
     CAPABILITY_NO_DONE,
     CAPABILITY_NO_PROGRESS,
     CAPABILITY_OFS_DELTA,
     CAPABILITY_QUIET,
     CAPABILITY_REPORT_STATUS,
     CAPABILITY_SHALLOW,
     CAPABILITY_SIDE_BAND_64K,
     CAPABILITY_THIN_PACK,
     COMMAND_DEEPEN,
     COMMAND_DONE,
     COMMAND_HAVE,
     COMMAND_SHALLOW,
     COMMAND_UNSHALLOW,
     COMMAND_WANT,
     MULTI_ACK,
     MULTI_ACK_DETAILED,
     Protocol,
     ProtocolFile,
     ReceivableProtocol,
     SIDE_BAND_CHANNEL_DATA,
     SIDE_BAND_CHANNEL_PROGRESS,
     SIDE_BAND_CHANNEL_FATAL,
     SINGLE_ACK,
     TCP_GIT_PORT,
     ZERO_SHA,
     ack_type,
     extract_capabilities,
     extract_want_line_capabilities,
     symref_capabilities,
 )
 from dulwich.refs import (
     ANNOTATED_TAG_SUFFIX,
     write_info_refs,
 )
 from dulwich.repo import (
     BaseRepo,
     Repo,
 )
 
 
 logger = log_utils.getLogger(__name__)
 
 
 class Backend(object):
     """A backend for the Git smart server implementation."""
 
     def open_repository(self, path):
         """Open the repository at a path.
 
         Args:
           path: Path to the repository
         Raises:
           NotGitRepository: no git repository was found at path
         Returns: Instance of BackendRepo
         """
         raise NotImplementedError(self.open_repository)
 
 
 class BackendRepo(object):
     """Repository abstraction used by the Git server.
 
     The methods required here are a subset of those provided by
     dulwich.repo.Repo.
     """
 
     object_store = None
     refs = None
 
     def get_refs(self) -> Dict[bytes, bytes]:
         """
         Get all the refs in the repository
 
         Returns: dict of name -> sha
         """
         raise NotImplementedError
 
     def get_peeled(self, name: bytes) -> Optional[bytes]:
         """Return the cached peeled value of a ref, if available.
 
         Args:
           name: Name of the ref to peel
         Returns: The peeled value of the ref. If the ref is known not point to
             a tag, this will be the SHA the ref refers to. If no cached
             information about a tag is available, this method may return None,
             but it should attempt to peel the tag if possible.
         """
         return None
 
     def fetch_objects(self, determine_wants, graph_walker, progress, get_tagged=None):
         """
         Yield the objects required for a list of commits.
 
         Args:
           progress: is a callback to send progress messages to the client
           get_tagged: Function that returns a dict of pointed-to sha ->
             tag sha for including tags.
         """
         raise NotImplementedError
 
 
 class DictBackend(Backend):
     """Trivial backend that looks up Git repositories in a dictionary."""
 
     def __init__(self, repos):
         self.repos = repos
 
     def open_repository(self, path: str) -> BaseRepo:
         logger.debug("Opening repository at %s", path)
         try:
             return self.repos[path]
         except KeyError:
             raise NotGitRepository(
                 "No git repository was found at %(path)s" % dict(path=path)
             )
 
 
 class FileSystemBackend(Backend):
     """Simple backend looking up Git repositories in the local file system."""
 
     def __init__(self, root=os.sep):
         super(FileSystemBackend, self).__init__()
         self.root = (os.path.abspath(root) + os.sep).replace(os.sep * 2, os.sep)
 
     def open_repository(self, path):
         logger.debug("opening repository at %s", path)
         abspath = os.path.abspath(os.path.join(self.root, path)) + os.sep
         normcase_abspath = os.path.normcase(abspath)
         normcase_root = os.path.normcase(self.root)
         if not normcase_abspath.startswith(normcase_root):
             raise NotGitRepository("Path %r not inside root %r" % (path, self.root))
         return Repo(abspath)
 
 
 class Handler(object):
     """Smart protocol command handler base class."""
 
     def __init__(self, backend, proto, stateless_rpc=None):
         self.backend = backend
         self.proto = proto
         self.stateless_rpc = stateless_rpc
 
     def handle(self):
         raise NotImplementedError(self.handle)
 
 
 class PackHandler(Handler):
     """Protocol handler for packs."""
 
     def __init__(self, backend, proto, stateless_rpc=None):
         super(PackHandler, self).__init__(backend, proto, stateless_rpc)
         self._client_capabilities = None
         # Flags needed for the no-done capability
         self._done_received = False
 
     @classmethod
     def capability_line(cls, capabilities):
         logger.info("Sending capabilities: %s", capabilities)
         return b"".join([b" " + c for c in capabilities])
 
     @classmethod
     def capabilities(cls) -> Iterable[bytes]:
         raise NotImplementedError(cls.capabilities)
 
     @classmethod
     def innocuous_capabilities(cls) -> Iterable[bytes]:
         return [
             CAPABILITY_INCLUDE_TAG,
             CAPABILITY_THIN_PACK,
             CAPABILITY_NO_PROGRESS,
             CAPABILITY_OFS_DELTA,
             capability_agent(),
         ]
 
     @classmethod
     def required_capabilities(cls) -> Iterable[bytes]:
         """Return a list of capabilities that we require the client to have."""
         return []
 
     def set_client_capabilities(self, caps: Iterable[bytes]) -> None:
         allowable_caps = set(self.innocuous_capabilities())
         allowable_caps.update(self.capabilities())
         for cap in caps:
             if cap.startswith(CAPABILITY_AGENT + b"="):
                 continue
             if cap not in allowable_caps:
                 raise GitProtocolError(
                     "Client asked for capability %r that " "was not advertised." % cap
                 )
         for cap in self.required_capabilities():
             if cap not in caps:
                 raise GitProtocolError(
                     "Client does not support required " "capability %r." % cap
                 )
         self._client_capabilities = set(caps)
         logger.info("Client capabilities: %s", caps)
 
     def has_capability(self, cap: bytes) -> bool:
         if self._client_capabilities is None:
             raise GitProtocolError(
                 "Server attempted to access capability %r " "before asking client" % cap
             )
         return cap in self._client_capabilities
 
     def notify_done(self) -> None:
         self._done_received = True
 
 
 class UploadPackHandler(PackHandler):
     """Protocol handler for uploading a pack to the client."""
 
     def __init__(self, backend, args, proto, stateless_rpc=None, advertise_refs=False):
         super(UploadPackHandler, self).__init__(
             backend, proto, stateless_rpc=stateless_rpc
         )
         self.repo = backend.open_repository(args[0])
         self._graph_walker = None
         self.advertise_refs = advertise_refs
         # A state variable for denoting that the have list is still
         # being processed, and the client is not accepting any other
         # data (such as side-band, see the progress method here).
         self._processing_have_lines = False
 
     @classmethod
     def capabilities(cls):
         return [
             CAPABILITY_MULTI_ACK_DETAILED,
             CAPABILITY_MULTI_ACK,
             CAPABILITY_SIDE_BAND_64K,
             CAPABILITY_THIN_PACK,
             CAPABILITY_OFS_DELTA,
             CAPABILITY_NO_PROGRESS,
             CAPABILITY_INCLUDE_TAG,
             CAPABILITY_SHALLOW,
             CAPABILITY_NO_DONE,
         ]
 
     @classmethod
     def required_capabilities(cls):
         return (
             CAPABILITY_SIDE_BAND_64K,
             CAPABILITY_THIN_PACK,
             CAPABILITY_OFS_DELTA,
         )
 
     def progress(self, message):
         if self.has_capability(CAPABILITY_NO_PROGRESS) or self._processing_have_lines:
             return
         self.proto.write_sideband(SIDE_BAND_CHANNEL_PROGRESS, message)
 
     def get_tagged(self, refs=None, repo=None):
         """Get a dict of peeled values of tags to their original tag shas.
 
         Args:
           refs: dict of refname -> sha of possible tags; defaults to all
             of the backend's refs.
           repo: optional Repo instance for getting peeled refs; defaults
             to the backend's repo, if available
         Returns: dict of peeled_sha -> tag_sha, where tag_sha is the sha of a
             tag whose peeled value is peeled_sha.
         """
         if not self.has_capability(CAPABILITY_INCLUDE_TAG):
             return {}
         if refs is None:
             refs = self.repo.get_refs()
         if repo is None:
             repo = getattr(self.repo, "repo", None)
             if repo is None:
                 # Bail if we don't have a Repo available; this is ok since
                 # clients must be able to handle if the server doesn't include
                 # all relevant tags.
                 # TODO: fix behavior when missing
                 return {}
         # TODO(jelmer): Integrate this with the refs logic in
         # Repo.fetch_objects
         tagged = {}
         for name, sha in refs.items():
             peeled_sha = repo.get_peeled(name)
             if peeled_sha != sha:
                 tagged[peeled_sha] = sha
         return tagged
 
     def handle(self):
         def write(x):
             return self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, x)
 
         graph_walker = _ProtocolGraphWalker(
             self,
             self.repo.object_store,
             self.repo.get_peeled,
             self.repo.refs.get_symrefs,
         )
         wants = []
 
-        def wants_wrapper(refs):
-            wants.extend(graph_walker.determine_wants(refs))
+        def wants_wrapper(refs, **kwargs):
+            wants.extend(graph_walker.determine_wants(refs, **kwargs))
             return wants
 
         objects_iter = self.repo.fetch_objects(
             wants_wrapper,
             graph_walker,
             self.progress,
             get_tagged=self.get_tagged,
         )
 
         # Note the fact that client is only processing responses related
         # to the have lines it sent, and any other data (including side-
         # band) will be be considered a fatal error.
         self._processing_have_lines = True
 
         # 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.
         # Also, if it also happens that the object_iter is instantiated
         # with a graph walker with an implementation that talks over the
         # wire (which is this instance of this class) this will actually
         # iterate through everything and write things out to the wire.
         if len(wants) == 0:
             return
 
         # The provided haves are processed, and it is safe to send side-
         # band data now.
         self._processing_have_lines = False
 
         if not graph_walker.handle_done(
             not self.has_capability(CAPABILITY_NO_DONE), self._done_received
         ):
             return
 
         self.progress(
             ("counting objects: %d, done.\n" % len(objects_iter)).encode("ascii")
         )
         write_pack_objects(ProtocolFile(None, write), objects_iter)
         # we are done
         self.proto.write_pkt_line(None)
 
 
 def _split_proto_line(line, allowed):
     """Split a line read from the wire.
 
     Args:
       line: The line read from the wire.
       allowed: An iterable of command names that should be allowed.
         Command names not listed below as possible return values will be
         ignored.  If None, any commands from the possible return values are
         allowed.
     Returns: a tuple having one of the following forms:
         ('want', obj_id)
         ('have', obj_id)
         ('done', None)
         (None, None)  (for a flush-pkt)
 
     Raises:
       UnexpectedCommandError: if the line cannot be parsed into one of the
         allowed return values.
     """
     if not line:
         fields = [None]
     else:
         fields = line.rstrip(b"\n").split(b" ", 1)
     command = fields[0]
     if allowed is not None and command not in allowed:
         raise UnexpectedCommandError(command)
     if len(fields) == 1 and command in (COMMAND_DONE, None):
         return (command, None)
     elif len(fields) == 2:
         if command in (
             COMMAND_WANT,
             COMMAND_HAVE,
             COMMAND_SHALLOW,
             COMMAND_UNSHALLOW,
         ):
             if not valid_hexsha(fields[1]):
                 raise GitProtocolError("Invalid sha")
             return tuple(fields)
         elif command == COMMAND_DEEPEN:
             return command, int(fields[1])
     raise GitProtocolError("Received invalid line from client: %r" % line)
 
 
 def _find_shallow(store, heads, depth):
     """Find shallow commits according to a given depth.
 
     Args:
       store: An ObjectStore for looking up objects.
       heads: Iterable of head SHAs to start walking from.
       depth: The depth of ancestors to include. A depth of one includes
         only the heads themselves.
     Returns: A tuple of (shallow, not_shallow), sets of SHAs that should be
         considered shallow and unshallow according to the arguments. Note that
         these sets may overlap if a commit is reachable along multiple paths.
     """
     parents = {}
 
     def get_parents(sha):
         result = parents.get(sha, None)
         if not result:
             result = store[sha].parents
             parents[sha] = result
         return result
 
     todo = []  # stack of (sha, depth)
     for head_sha in heads:
         obj = store.peel_sha(head_sha)
         if isinstance(obj, Commit):
             todo.append((obj.id, 1))
 
     not_shallow = set()
     shallow = set()
     while todo:
         sha, cur_depth = todo.pop()
         if cur_depth < depth:
             not_shallow.add(sha)
             new_depth = cur_depth + 1
             todo.extend((p, new_depth) for p in get_parents(sha))
         else:
             shallow.add(sha)
 
     return shallow, not_shallow
 
 
 def _want_satisfied(store, haves, want, earliest):
     o = store[want]
     pending = collections.deque([o])
     known = set([want])
     while pending:
         commit = pending.popleft()
         if commit.id in haves:
             return True
         if commit.type_name != b"commit":
             # non-commit wants are assumed to be satisfied
             continue
         for parent in commit.parents:
             if parent in known:
                 continue
             known.add(parent)
             parent_obj = store[parent]
             # TODO: handle parents with later commit times than children
             if parent_obj.commit_time >= earliest:
                 pending.append(parent_obj)
     return False
 
 
 def _all_wants_satisfied(store, haves, wants):
     """Check whether all the current wants are satisfied by a set of haves.
 
     Args:
       store: Object store to retrieve objects from
       haves: A set of commits we know the client has.
       wants: A set of commits the client wants
     Note: Wants are specified with set_wants rather than passed in since
         in the current interface they are determined outside this class.
     """
     haves = set(haves)
     if haves:
         earliest = min([store[h].commit_time for h in haves])
     else:
         earliest = 0
     for want in wants:
         if not _want_satisfied(store, haves, want, earliest):
             return False
 
     return True
 
 
 class _ProtocolGraphWalker(object):
     """A graph walker that knows the git protocol.
 
     As a graph walker, this class implements ack(), next(), and reset(). It
     also contains some base methods for interacting with the wire and walking
     the commit tree.
 
     The work of determining which acks to send is passed on to the
     implementation instance stored in _impl. The reason for this is that we do
     not know at object creation time what ack level the protocol requires. A
     call to set_ack_type() is required to set up the implementation, before
     any calls to next() or ack() are made.
     """
 
     def __init__(self, handler, object_store, get_peeled, get_symrefs):
         self.handler = handler
         self.store = object_store
         self.get_peeled = get_peeled
         self.get_symrefs = get_symrefs
         self.proto = handler.proto
         self.stateless_rpc = handler.stateless_rpc
         self.advertise_refs = handler.advertise_refs
         self._wants = []
         self.shallow = set()
         self.client_shallow = set()
         self.unshallow = set()
         self._cached = False
         self._cache = []
         self._cache_index = 0
         self._impl = None
 
-    def determine_wants(self, heads):
+    def determine_wants(self, heads, depth=None):
         """Determine the wants for a set of heads.
 
         The given heads are advertised to the client, who then specifies which
         refs they want using 'want' lines. This portion of the protocol is the
         same regardless of ack type, and in fact is used to set the ack type of
         the ProtocolGraphWalker.
 
         If the client has the 'shallow' capability, this method also reads and
         responds to the 'shallow' and 'deepen' lines from the client. These are
         not part of the wants per se, but they set up necessary state for
         walking the graph. Additionally, later code depends on this method
         consuming everything up to the first 'have' line.
 
         Args:
           heads: a dict of refname->SHA1 to advertise
         Returns: a list of SHA1s requested by the client
         """
         symrefs = self.get_symrefs()
         values = set(heads.values())
         if self.advertise_refs or not self.stateless_rpc:
             for i, (ref, sha) in enumerate(sorted(heads.items())):
                 try:
                     peeled_sha = self.get_peeled(ref)
                 except KeyError:
                     # Skip refs that are inaccessible
                     # TODO(jelmer): Integrate with Repo.fetch_objects refs
                     # logic.
                     continue
                 line = sha + b" " + ref
                 if not i:
                     line += b"\x00" + self.handler.capability_line(
                         self.handler.capabilities()
                         + symref_capabilities(symrefs.items())
                     )
                 self.proto.write_pkt_line(line + b"\n")
                 if peeled_sha != sha:
                     self.proto.write_pkt_line(
                         peeled_sha + b" " + ref + ANNOTATED_TAG_SUFFIX + b"\n"
                     )
 
             # i'm done..
             self.proto.write_pkt_line(None)
 
             if self.advertise_refs:
                 return []
 
         # Now client will sending want want want commands
         want = self.proto.read_pkt_line()
         if not want:
             return []
         line, caps = extract_want_line_capabilities(want)
         self.handler.set_client_capabilities(caps)
         self.set_ack_type(ack_type(caps))
         allowed = (COMMAND_WANT, COMMAND_SHALLOW, COMMAND_DEEPEN, None)
         command, sha = _split_proto_line(line, allowed)
 
         want_revs = []
         while command == COMMAND_WANT:
             if sha not in values:
                 raise GitProtocolError("Client wants invalid object %s" % sha)
             want_revs.append(sha)
             command, sha = self.read_proto_line(allowed)
 
         self.set_wants(want_revs)
         if command in (COMMAND_SHALLOW, COMMAND_DEEPEN):
             self.unread_proto_line(command, sha)
             self._handle_shallow_request(want_revs)
 
         if self.stateless_rpc and self.proto.eof():
             # The client may close the socket at this point, expecting a
             # flush-pkt from the server. We might be ready to send a packfile
             # at this point, so we need to explicitly short-circuit in this
             # case.
             return []
 
         return want_revs
 
     def unread_proto_line(self, command, value):
         if isinstance(value, int):
             value = str(value).encode("ascii")
         self.proto.unread_pkt_line(command + b" " + value)
 
     def ack(self, have_ref):
         if len(have_ref) != 40:
             raise ValueError("invalid sha %r" % have_ref)
         return self._impl.ack(have_ref)
 
     def reset(self):
         self._cached = True
         self._cache_index = 0
 
     def next(self):
         if not self._cached:
             if not self._impl and self.stateless_rpc:
                 return None
             return next(self._impl)
         self._cache_index += 1
         if self._cache_index > len(self._cache):
             return None
         return self._cache[self._cache_index]
 
     __next__ = next
 
     def read_proto_line(self, allowed):
         """Read a line from the wire.
 
         Args:
           allowed: An iterable of command names that should be allowed.
         Returns: A tuple of (command, value); see _split_proto_line.
         Raises:
           UnexpectedCommandError: If an error occurred reading the line.
         """
         return _split_proto_line(self.proto.read_pkt_line(), allowed)
 
     def _handle_shallow_request(self, wants):
         while True:
             command, val = self.read_proto_line((COMMAND_DEEPEN, COMMAND_SHALLOW))
             if command == COMMAND_DEEPEN:
                 depth = val
                 break
             self.client_shallow.add(val)
         self.read_proto_line((None,))  # consume client's flush-pkt
 
         shallow, not_shallow = _find_shallow(self.store, wants, depth)
 
         # Update self.shallow instead of reassigning it since we passed a
         # reference to it before this method was called.
         self.shallow.update(shallow - not_shallow)
         new_shallow = self.shallow - self.client_shallow
         unshallow = self.unshallow = not_shallow & self.client_shallow
 
         for sha in sorted(new_shallow):
             self.proto.write_pkt_line(COMMAND_SHALLOW + b" " + sha)
         for sha in sorted(unshallow):
             self.proto.write_pkt_line(COMMAND_UNSHALLOW + b" " + sha)
 
         self.proto.write_pkt_line(None)
 
     def notify_done(self):
         # relay the message down to the handler.
         self.handler.notify_done()
 
     def send_ack(self, sha, ack_type=b""):
         if ack_type:
             ack_type = b" " + ack_type
         self.proto.write_pkt_line(b"ACK " + sha + ack_type + b"\n")
 
     def send_nak(self):
         self.proto.write_pkt_line(b"NAK\n")
 
     def handle_done(self, done_required, done_received):
         # Delegate this to the implementation.
         return self._impl.handle_done(done_required, done_received)
 
     def set_wants(self, wants):
         self._wants = wants
 
     def all_wants_satisfied(self, haves):
         """Check whether all the current wants are satisfied by a set of haves.
 
         Args:
           haves: A set of commits we know the client has.
         Note: Wants are specified with set_wants rather than passed in since
             in the current interface they are determined outside this class.
         """
         return _all_wants_satisfied(self.store, haves, self._wants)
 
     def set_ack_type(self, ack_type):
         impl_classes = {
             MULTI_ACK: MultiAckGraphWalkerImpl,
             MULTI_ACK_DETAILED: MultiAckDetailedGraphWalkerImpl,
             SINGLE_ACK: SingleAckGraphWalkerImpl,
         }
         self._impl = impl_classes[ack_type](self)
 
 
 _GRAPH_WALKER_COMMANDS = (COMMAND_HAVE, COMMAND_DONE, None)
 
 
 class SingleAckGraphWalkerImpl(object):
     """Graph walker implementation that speaks the single-ack protocol."""
 
     def __init__(self, walker):
         self.walker = walker
         self._common = []
 
     def ack(self, have_ref):
         if not self._common:
             self.walker.send_ack(have_ref)
             self._common.append(have_ref)
 
     def next(self):
         command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
         if command in (None, COMMAND_DONE):
             # defer the handling of done
             self.walker.notify_done()
             return None
         elif command == COMMAND_HAVE:
             return sha
 
     __next__ = next
 
     def handle_done(self, done_required, done_received):
         if not self._common:
             self.walker.send_nak()
 
         if done_required and not done_received:
             # we are not done, especially when done is required; skip
             # the pack for this request and especially do not handle
             # the done.
             return False
 
         if not done_received and not self._common:
             # Okay we are not actually done then since the walker picked
             # up no haves.  This is usually triggered when client attempts
             # to pull from a source that has no common base_commit.
             # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
             #          test_multi_ack_stateless_nodone
             return False
 
         return True
 
 
 class MultiAckGraphWalkerImpl(object):
     """Graph walker implementation that speaks the multi-ack protocol."""
 
     def __init__(self, walker):
         self.walker = walker
         self._found_base = False
         self._common = []
 
     def ack(self, have_ref):
         self._common.append(have_ref)
         if not self._found_base:
             self.walker.send_ack(have_ref, b"continue")
             if self.walker.all_wants_satisfied(self._common):
                 self._found_base = True
         # else we blind ack within next
 
     def next(self):
         while True:
             command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
             if command is None:
                 self.walker.send_nak()
                 # in multi-ack mode, a flush-pkt indicates the client wants to
                 # flush but more have lines are still coming
                 continue
             elif command == COMMAND_DONE:
                 self.walker.notify_done()
                 return None
             elif command == COMMAND_HAVE:
                 if self._found_base:
                     # blind ack
                     self.walker.send_ack(sha, b"continue")
                 return sha
 
     __next__ = next
 
     def handle_done(self, done_required, done_received):
         if done_required and not done_received:
             # we are not done, especially when done is required; skip
             # the pack for this request and especially do not handle
             # the done.
             return False
 
         if not done_received and not self._common:
             # Okay we are not actually done then since the walker picked
             # up no haves.  This is usually triggered when client attempts
             # to pull from a source that has no common base_commit.
             # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
             #          test_multi_ack_stateless_nodone
             return False
 
         # don't nak unless no common commits were found, even if not
         # everything is satisfied
         if self._common:
             self.walker.send_ack(self._common[-1])
         else:
             self.walker.send_nak()
         return True
 
 
 class MultiAckDetailedGraphWalkerImpl(object):
     """Graph walker implementation speaking the multi-ack-detailed protocol."""
 
     def __init__(self, walker):
         self.walker = walker
         self._common = []
 
     def ack(self, have_ref):
         # Should only be called iff have_ref is common
         self._common.append(have_ref)
         self.walker.send_ack(have_ref, b"common")
 
     def next(self):
         while True:
             command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
             if command is None:
                 if self.walker.all_wants_satisfied(self._common):
                     self.walker.send_ack(self._common[-1], b"ready")
                 self.walker.send_nak()
                 if self.walker.stateless_rpc:
                     # The HTTP version of this request a flush-pkt always
                     # signifies an end of request, so we also return
                     # nothing here as if we are done (but not really, as
                     # it depends on whether no-done capability was
                     # specified and that's handled in handle_done which
                     # may or may not call post_nodone_check depending on
                     # that).
                     return None
             elif command == COMMAND_DONE:
                 # Let the walker know that we got a done.
                 self.walker.notify_done()
                 break
             elif command == COMMAND_HAVE:
                 # return the sha and let the caller ACK it with the
                 # above ack method.
                 return sha
         # don't nak unless no common commits were found, even if not
         # everything is satisfied
 
     __next__ = next
 
     def handle_done(self, done_required, done_received):
         if done_required and not done_received:
             # we are not done, especially when done is required; skip
             # the pack for this request and especially do not handle
             # the done.
             return False
 
         if not done_received and not self._common:
             # Okay we are not actually done then since the walker picked
             # up no haves.  This is usually triggered when client attempts
             # to pull from a source that has no common base_commit.
             # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
             #          test_multi_ack_stateless_nodone
             return False
 
         # don't nak unless no common commits were found, even if not
         # everything is satisfied
         if self._common:
             self.walker.send_ack(self._common[-1])
         else:
             self.walker.send_nak()
         return True
 
 
 class ReceivePackHandler(PackHandler):
     """Protocol handler for downloading a pack from the client."""
 
     def __init__(self, backend, args, proto, stateless_rpc=None, advertise_refs=False):
         super(ReceivePackHandler, self).__init__(
             backend, proto, stateless_rpc=stateless_rpc
         )
         self.repo = backend.open_repository(args[0])
         self.advertise_refs = advertise_refs
 
     @classmethod
     def capabilities(cls) -> Iterable[bytes]:
         return [
             CAPABILITY_REPORT_STATUS,
             CAPABILITY_DELETE_REFS,
             CAPABILITY_QUIET,
             CAPABILITY_OFS_DELTA,
             CAPABILITY_SIDE_BAND_64K,
             CAPABILITY_NO_DONE,
         ]
 
     def _apply_pack(
         self, refs: List[Tuple[bytes, bytes, bytes]]
     ) -> List[Tuple[bytes, bytes]]:
         all_exceptions = (
             IOError,
             OSError,
             ChecksumMismatch,
             ApplyDeltaError,
             AssertionError,
             socket.error,
             zlib.error,
             ObjectFormatException,
         )
         status = []
         will_send_pack = False
 
         for command in refs:
             if command[1] != ZERO_SHA:
                 will_send_pack = True
 
         if will_send_pack:
             # TODO: more informative error messages than just the exception
             # string
             try:
                 recv = getattr(self.proto, "recv", None)
                 self.repo.object_store.add_thin_pack(self.proto.read, recv)
                 status.append((b"unpack", b"ok"))
             except all_exceptions as e:
                 status.append((b"unpack", str(e).replace("\n", "").encode("utf-8")))
                 # The pack may still have been moved in, but it may contain
                 # broken objects. We trust a later GC to clean it up.
         else:
             # The git protocol want to find a status entry related to unpack
             # process even if no pack data has been sent.
             status.append((b"unpack", b"ok"))
 
         for oldsha, sha, ref in refs:
             ref_status = b"ok"
             try:
                 if sha == ZERO_SHA:
                     if CAPABILITY_DELETE_REFS not in self.capabilities():
                         raise GitProtocolError(
                             "Attempted to delete refs without delete-refs "
                             "capability."
                         )
                     try:
                         self.repo.refs.remove_if_equals(ref, oldsha)
                     except all_exceptions:
                         ref_status = b"failed to delete"
                 else:
                     try:
                         self.repo.refs.set_if_equals(ref, oldsha, sha)
                     except all_exceptions:
                         ref_status = b"failed to write"
             except KeyError:
                 ref_status = b"bad ref"
             status.append((ref, ref_status))
 
         return status
 
     def _report_status(self, status: List[Tuple[bytes, bytes]]) -> None:
         if self.has_capability(CAPABILITY_SIDE_BAND_64K):
             writer = BufferedPktLineWriter(
                 lambda d: self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, d)
             )
             write = writer.write
 
             def flush():
                 writer.flush()
                 self.proto.write_pkt_line(None)
 
         else:
             write = self.proto.write_pkt_line
 
             def flush():
                 pass
 
         for name, msg in status:
             if name == b"unpack":
                 write(b"unpack " + msg + b"\n")
             elif msg == b"ok":
                 write(b"ok " + name + b"\n")
             else:
                 write(b"ng " + name + b" " + msg + b"\n")
         write(None)
         flush()
 
     def _on_post_receive(self, client_refs):
         hook = self.repo.hooks.get("post-receive", None)
         if not hook:
             return
         try:
             output = hook.execute(client_refs)
             if output:
                 self.proto.write_sideband(SIDE_BAND_CHANNEL_PROGRESS, output)
         except HookError as err:
             self.proto.write_sideband(SIDE_BAND_CHANNEL_FATAL, str(err).encode('utf-8'))
 
     def handle(self) -> None:
         if self.advertise_refs or not self.stateless_rpc:
             refs = sorted(self.repo.get_refs().items())
             symrefs = sorted(self.repo.refs.get_symrefs().items())
 
             if not refs:
                 refs = [(CAPABILITIES_REF, ZERO_SHA)]
             self.proto.write_pkt_line(
                 refs[0][1]
                 + b" "
                 + refs[0][0]
                 + b"\0"
                 + self.capability_line(
                     self.capabilities() + symref_capabilities(symrefs)
                 )
                 + b"\n"
             )
             for i in range(1, len(refs)):
                 ref = refs[i]
                 self.proto.write_pkt_line(ref[1] + b" " + ref[0] + b"\n")
 
             self.proto.write_pkt_line(None)
             if self.advertise_refs:
                 return
 
         client_refs = []
         ref = self.proto.read_pkt_line()
 
         # if ref is none then client doesnt want to send us anything..
         if ref is None:
             return
 
         ref, caps = extract_capabilities(ref)
         self.set_client_capabilities(caps)
 
         # client will now send us a list of (oldsha, newsha, ref)
         while ref:
             client_refs.append(ref.split())
             ref = self.proto.read_pkt_line()
 
         # backend can now deal with this refs and read a pack using self.read
         status = self._apply_pack(client_refs)
 
         self._on_post_receive(client_refs)
 
         # when we have read all the pack from the client, send a status report
         # if the client asked for it
         if self.has_capability(CAPABILITY_REPORT_STATUS):
             self._report_status(status)
 
 
 class UploadArchiveHandler(Handler):
     def __init__(self, backend, args, proto, stateless_rpc=None):
         super(UploadArchiveHandler, self).__init__(backend, proto, stateless_rpc)
         self.repo = backend.open_repository(args[0])
 
     def handle(self):
         def write(x):
             return self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, x)
 
         arguments = []
         for pkt in self.proto.read_pkt_seq():
             (key, value) = pkt.split(b" ", 1)
             if key != b"argument":
                 raise GitProtocolError("unknown command %s" % key)
             arguments.append(value.rstrip(b"\n"))
         prefix = b""
         format = "tar"
         i = 0
         store = self.repo.object_store
         while i < len(arguments):
             argument = arguments[i]
             if argument == b"--prefix":
                 i += 1
                 prefix = arguments[i]
             elif argument == b"--format":
                 i += 1
                 format = arguments[i].decode("ascii")
             else:
                 commit_sha = self.repo.refs[argument]
                 tree = store[store[commit_sha].tree]
             i += 1
         self.proto.write_pkt_line(b"ACK")
         self.proto.write_pkt_line(None)
         for chunk in tar_stream(
             store, tree, mtime=time.time(), prefix=prefix, format=format
         ):
             write(chunk)
         self.proto.write_pkt_line(None)
 
 
 # Default handler classes for git services.
 DEFAULT_HANDLERS = {
     b"git-upload-pack": UploadPackHandler,
     b"git-receive-pack": ReceivePackHandler,
     b"git-upload-archive": UploadArchiveHandler,
 }
 
 
 class TCPGitRequestHandler(socketserver.StreamRequestHandler):
     def __init__(self, handlers, *args, **kwargs):
         self.handlers = handlers
         socketserver.StreamRequestHandler.__init__(self, *args, **kwargs)
 
     def handle(self):
         proto = ReceivableProtocol(self.connection.recv, self.wfile.write)
         command, args = proto.read_cmd()
         logger.info("Handling %s request, args=%s", command, args)
 
         cls = self.handlers.get(command, None)
         if not callable(cls):
             raise GitProtocolError("Invalid service %s" % command)
         h = cls(self.server.backend, args, proto)
         h.handle()
 
 
 class TCPGitServer(socketserver.TCPServer):
 
     allow_reuse_address = True
     serve = socketserver.TCPServer.serve_forever
 
     def _make_handler(self, *args, **kwargs):
         return TCPGitRequestHandler(self.handlers, *args, **kwargs)
 
     def __init__(self, backend, listen_addr, port=TCP_GIT_PORT, handlers=None):
         self.handlers = dict(DEFAULT_HANDLERS)
         if handlers is not None:
             self.handlers.update(handlers)
         self.backend = backend
         logger.info("Listening for TCP connections on %s:%d", listen_addr, port)
         socketserver.TCPServer.__init__(self, (listen_addr, port), self._make_handler)
 
     def verify_request(self, request, client_address):
         logger.info("Handling request from %s", client_address)
         return True
 
     def handle_error(self, request, client_address):
         logger.exception(
             "Exception happened during processing of request " "from %s",
             client_address,
         )
 
 
 def main(argv=sys.argv):
     """Entry point for starting a TCP git server."""
     import optparse
 
     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(argv)
 
     log_utils.default_logging_config()
     if len(args) > 1:
         gitdir = args[1]
     else:
         gitdir = "."
     # TODO(jelmer): Support git-daemon-export-ok and --export-all.
     backend = FileSystemBackend(gitdir)
     server = TCPGitServer(backend, options.listen_address, options.port)
     server.serve_forever()
 
 
 def serve_command(
     handler_cls, argv=sys.argv, backend=None, inf=sys.stdin, outf=sys.stdout
 ):
     """Serve a single command.
 
     This is mostly useful for the implementation of commands used by e.g.
     git+ssh.
 
     Args:
       handler_cls: `Handler` class to use for the request
       argv: execv-style command-line arguments. Defaults to sys.argv.
       backend: `Backend` to use
       inf: File-like object to read from, defaults to standard input.
       outf: File-like object to write to, defaults to standard output.
     Returns: Exit code for use with sys.exit. 0 on success, 1 on failure.
     """
     if backend is None:
         backend = FileSystemBackend()
 
     def send_fn(data):
         outf.write(data)
         outf.flush()
 
     proto = Protocol(inf.read, send_fn)
     handler = handler_cls(backend, argv[1:], proto)
     # FIXME: Catch exceptions and write a single-line summary to outf.
     handler.handle()
     return 0
 
 
 def generate_info_refs(repo):
     """Generate an info refs file."""
     refs = repo.get_refs()
     return write_info_refs(refs, repo.object_store)
 
 
 def generate_objects_info_packs(repo):
     """Generate an index for for packs."""
     for pack in repo.object_store.packs:
         yield (b"P " + os.fsencode(pack.data.filename) + b"\n")
 
 
 def update_server_info(repo):
     """Generate server info for dumb file access.
 
     This generates info/refs and objects/info/packs,
     similar to "git update-server-info".
     """
     repo._put_named_file(
         os.path.join("info", "refs"), b"".join(generate_info_refs(repo))
     )
 
     repo._put_named_file(
         os.path.join("objects", "info", "packs"),
         b"".join(generate_objects_info_packs(repo)),
     )
 
 
 if __name__ == "__main__":
     main()
diff --git a/dulwich/tests/compat/test_client.py b/dulwich/tests/compat/test_client.py
index 1cb3cc99..965f5c54 100644
--- a/dulwich/tests/compat/test_client.py
+++ b/dulwich/tests/compat/test_client.py
@@ -1,661 +1,661 @@
 # test_client.py -- Compatibilty tests for git client.
 # 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.
 #
 
 """Compatibilty tests between the Dulwich client and the cgit server."""
 
 import copy
 from io import BytesIO
 import os
 import select
 import signal
 import stat
 import subprocess
 import sys
 import tarfile
 import tempfile
 import threading
 
 from urllib.parse import unquote
 
 import http.server
 
 from dulwich import (
     client,
     file,
     index,
     protocol,
     objects,
     repo,
 )
 from dulwich.tests import (
     SkipTest,
     expectedFailure,
 )
 from dulwich.tests.compat.utils import (
     CompatTestCase,
     check_for_daemon,
     import_repo_to_dir,
     rmtree_ro,
     run_git_or_fail,
     _DEFAULT_GIT,
 )
 
 
 if sys.platform == "win32":
     import ctypes
 
 
 class DulwichClientTestBase(object):
     """Tests for client/server compatibility."""
 
     def setUp(self):
         self.gitroot = os.path.dirname(
             import_repo_to_dir("server_new.export").rstrip(os.sep)
         )
         self.dest = os.path.join(self.gitroot, "dest")
         file.ensure_dir_exists(self.dest)
         run_git_or_fail(["init", "--quiet", "--bare"], cwd=self.dest)
 
     def tearDown(self):
         rmtree_ro(self.gitroot)
 
     def assertDestEqualsSrc(self):
         repo_dir = os.path.join(self.gitroot, "server_new.export")
         dest_repo_dir = os.path.join(self.gitroot, "dest")
         with repo.Repo(repo_dir) as src:
             with repo.Repo(dest_repo_dir) as dest:
                 self.assertReposEqual(src, dest)
 
     def _client(self):
         raise NotImplementedError()
 
     def _build_path(self):
         raise NotImplementedError()
 
     def _do_send_pack(self):
         c = self._client()
         srcpath = os.path.join(self.gitroot, "server_new.export")
         with repo.Repo(srcpath) as src:
             sendrefs = dict(src.get_refs())
             del sendrefs[b"HEAD"]
             c.send_pack(
                 self._build_path("/dest"),
                 lambda _: sendrefs,
                 src.generate_pack_data,
             )
 
     def test_send_pack(self):
         self._do_send_pack()
         self.assertDestEqualsSrc()
 
     def test_send_pack_nothing_to_send(self):
         self._do_send_pack()
         self.assertDestEqualsSrc()
         # nothing to send, but shouldn't raise either.
         self._do_send_pack()
 
     @staticmethod
     def _add_file(repo, tree_id, filename, contents):
         tree = repo[tree_id]
         blob = objects.Blob()
         blob.data = contents.encode("utf-8")
         repo.object_store.add_object(blob)
         tree.add(filename.encode("utf-8"), stat.S_IFREG | 0o644, blob.id)
         repo.object_store.add_object(tree)
         return tree.id
 
     def test_send_pack_from_shallow_clone(self):
         c = self._client()
         server_new_path = os.path.join(self.gitroot, "server_new.export")
         run_git_or_fail(["config", "http.uploadpack", "true"], cwd=server_new_path)
         run_git_or_fail(["config", "http.receivepack", "true"], cwd=server_new_path)
         remote_path = self._build_path("/server_new.export")
         with repo.Repo(self.dest) as local:
             result = c.fetch(remote_path, local, depth=1)
             for r in result.refs.items():
                 local.refs.set_if_equals(r[0], None, r[1])
             tree_id = local[local.head()].tree
             for filename, contents in [
                 ("bar", "bar contents"),
                 ("zop", "zop contents"),
             ]:
                 tree_id = self._add_file(local, tree_id, filename, contents)
                 commit_id = local.do_commit(
                     message=b"add " + filename.encode("utf-8"),
                     committer=b"Joe Example <joe@example.com>",
                     tree=tree_id,
                 )
             sendrefs = dict(local.get_refs())
             del sendrefs[b"HEAD"]
             c.send_pack(remote_path, lambda _: sendrefs, local.generate_pack_data)
         with repo.Repo(server_new_path) as remote:
             self.assertEqual(remote.head(), commit_id)
 
     def test_send_without_report_status(self):
         c = self._client()
         c._send_capabilities.remove(b"report-status")
         srcpath = os.path.join(self.gitroot, "server_new.export")
         with repo.Repo(srcpath) as src:
             sendrefs = dict(src.get_refs())
             del sendrefs[b"HEAD"]
             c.send_pack(
                 self._build_path("/dest"),
                 lambda _: sendrefs,
                 src.generate_pack_data,
             )
             self.assertDestEqualsSrc()
 
     def make_dummy_commit(self, dest):
         b = objects.Blob.from_string(b"hi")
         dest.object_store.add_object(b)
         t = index.commit_tree(dest.object_store, [(b"hi", b.id, 0o100644)])
         c = objects.Commit()
         c.author = c.committer = b"Foo Bar <foo@example.com>"
         c.author_time = c.commit_time = 0
         c.author_timezone = c.commit_timezone = 0
         c.message = b"hi"
         c.tree = t
         dest.object_store.add_object(c)
         return c.id
 
     def disable_ff_and_make_dummy_commit(self):
         # disable non-fast-forward pushes to the server
         dest = repo.Repo(os.path.join(self.gitroot, "dest"))
         run_git_or_fail(
             ["config", "receive.denyNonFastForwards", "true"], cwd=dest.path
         )
         commit_id = self.make_dummy_commit(dest)
         return dest, commit_id
 
     def compute_send(self, src):
         sendrefs = dict(src.get_refs())
         del sendrefs[b"HEAD"]
         return sendrefs, src.generate_pack_data
 
     def test_send_pack_one_error(self):
         dest, dummy_commit = self.disable_ff_and_make_dummy_commit()
         dest.refs[b"refs/heads/master"] = dummy_commit
         repo_dir = os.path.join(self.gitroot, "server_new.export")
         with repo.Repo(repo_dir) as src:
             sendrefs, gen_pack = self.compute_send(src)
             c = self._client()
             result = c.send_pack(
                 self._build_path("/dest"), lambda _: sendrefs, gen_pack
             )
             self.assertEqual(
                 {
                     b"refs/heads/branch": None,
                     b"refs/heads/master": "non-fast-forward",
                 },
                 result.ref_status,
             )
 
     def test_send_pack_multiple_errors(self):
         dest, dummy = self.disable_ff_and_make_dummy_commit()
         # set up for two non-ff errors
         branch, master = b"refs/heads/branch", b"refs/heads/master"
         dest.refs[branch] = dest.refs[master] = dummy
         repo_dir = os.path.join(self.gitroot, "server_new.export")
         with repo.Repo(repo_dir) as src:
             sendrefs, gen_pack = self.compute_send(src)
             c = self._client()
             result = c.send_pack(
                 self._build_path("/dest"), lambda _: sendrefs, gen_pack
             )
             self.assertEqual(
                 {branch: "non-fast-forward", master: "non-fast-forward"},
                 result.ref_status,
             )
 
     def test_archive(self):
         c = self._client()
         f = BytesIO()
         c.archive(self._build_path("/server_new.export"), b"HEAD", f.write)
         f.seek(0)
         tf = tarfile.open(fileobj=f)
         self.assertEqual(["baz", "foo"], tf.getnames())
 
     def test_fetch_pack(self):
         c = self._client()
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             result = c.fetch(self._build_path("/server_new.export"), dest)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_fetch_pack_depth(self):
         c = self._client()
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             result = c.fetch(self._build_path("/server_new.export"), dest, depth=1)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertEqual(
                 dest.get_shallow(),
                 set(
                     [
                         b"35e0b59e187dd72a0af294aedffc213eaa4d03ff",
                         b"514dc6d3fbfe77361bcaef320c4d21b72bc10be9",
                     ]
                 ),
             )
 
     def test_repeat(self):
         c = self._client()
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             result = c.fetch(self._build_path("/server_new.export"), dest)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
             result = c.fetch(self._build_path("/server_new.export"), dest)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_fetch_empty_pack(self):
         c = self._client()
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             result = c.fetch(self._build_path("/server_new.export"), dest)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
-            def dw(refs):
+            def dw(refs, **kwargs):
                 return list(refs.values())
 
             result = c.fetch(
                 self._build_path("/server_new.export"),
                 dest,
                 determine_wants=dw,
             )
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_incremental_fetch_pack(self):
         self.test_fetch_pack()
         dest, dummy = self.disable_ff_and_make_dummy_commit()
         dest.refs[b"refs/heads/master"] = dummy
         c = self._client()
         repo_dir = os.path.join(self.gitroot, "server_new.export")
         with repo.Repo(repo_dir) as dest:
             result = c.fetch(self._build_path("/dest"), dest)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_fetch_pack_no_side_band_64k(self):
         c = self._client()
         c._fetch_capabilities.remove(b"side-band-64k")
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             result = c.fetch(self._build_path("/server_new.export"), dest)
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_fetch_pack_zero_sha(self):
         # zero sha1s are already present on the client, and should
         # be ignored
         c = self._client()
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             result = c.fetch(
                 self._build_path("/server_new.export"),
                 dest,
-                lambda refs: [protocol.ZERO_SHA],
+                lambda refs, **kwargs: [protocol.ZERO_SHA],
             )
             for r in result.refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
 
     def test_send_remove_branch(self):
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             dummy_commit = self.make_dummy_commit(dest)
             dest.refs[b"refs/heads/master"] = dummy_commit
             dest.refs[b"refs/heads/abranch"] = dummy_commit
             sendrefs = dict(dest.refs)
             sendrefs[b"refs/heads/abranch"] = b"00" * 20
             del sendrefs[b"HEAD"]
 
             def gen_pack(have, want, ofs_delta=False):
                 return 0, []
 
             c = self._client()
             self.assertEqual(dest.refs[b"refs/heads/abranch"], dummy_commit)
             c.send_pack(self._build_path("/dest"), lambda _: sendrefs, gen_pack)
             self.assertFalse(b"refs/heads/abranch" in dest.refs)
 
     def test_send_new_branch_empty_pack(self):
         with repo.Repo(os.path.join(self.gitroot, "dest")) as dest:
             dummy_commit = self.make_dummy_commit(dest)
             dest.refs[b"refs/heads/master"] = dummy_commit
             dest.refs[b"refs/heads/abranch"] = dummy_commit
             sendrefs = {b"refs/heads/bbranch": dummy_commit}
 
             def gen_pack(have, want, ofs_delta=False):
                 return 0, []
 
             c = self._client()
             self.assertEqual(dest.refs[b"refs/heads/abranch"], dummy_commit)
             c.send_pack(self._build_path("/dest"), lambda _: sendrefs, gen_pack)
             self.assertEqual(dummy_commit, dest.refs[b"refs/heads/abranch"])
 
     def test_get_refs(self):
         c = self._client()
         refs = c.get_refs(self._build_path("/server_new.export"))
 
         repo_dir = os.path.join(self.gitroot, "server_new.export")
         with repo.Repo(repo_dir) as dest:
             self.assertDictEqual(dest.refs.as_dict(), refs)
 
 
 class DulwichTCPClientTest(CompatTestCase, DulwichClientTestBase):
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
         if check_for_daemon(limit=1):
             raise SkipTest(
                 "git-daemon was already running on port %s" % protocol.TCP_GIT_PORT
             )
         fd, self.pidfile = tempfile.mkstemp(
             prefix="dulwich-test-git-client", suffix=".pid"
         )
         os.fdopen(fd).close()
         args = [
             _DEFAULT_GIT,
             "daemon",
             "--verbose",
             "--export-all",
             "--pid-file=%s" % self.pidfile,
             "--base-path=%s" % self.gitroot,
             "--enable=receive-pack",
             "--enable=upload-archive",
             "--listen=localhost",
             "--reuseaddr",
             self.gitroot,
         ]
         self.process = subprocess.Popen(
             args,
             cwd=self.gitroot,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
         if not check_for_daemon():
             raise SkipTest("git-daemon failed to start")
 
     def tearDown(self):
         with open(self.pidfile) as f:
             pid = int(f.read().strip())
         if sys.platform == "win32":
             PROCESS_TERMINATE = 1
             handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
             ctypes.windll.kernel32.TerminateProcess(handle, -1)
             ctypes.windll.kernel32.CloseHandle(handle)
         else:
             try:
                 os.kill(pid, signal.SIGKILL)
                 os.unlink(self.pidfile)
             except (OSError, IOError):
                 pass
         self.process.wait()
         self.process.stdout.close()
         self.process.stderr.close()
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
 
     def _client(self):
         return client.TCPGitClient("localhost")
 
     def _build_path(self, path):
         return path
 
     if sys.platform == "win32":
 
         @expectedFailure
         def test_fetch_pack_no_side_band_64k(self):
             DulwichClientTestBase.test_fetch_pack_no_side_band_64k(self)
 
 
 class TestSSHVendor(object):
     @staticmethod
     def run_command(
         host,
         command,
         username=None,
         port=None,
         password=None,
         key_filename=None,
     ):
         cmd, path = command.split(" ")
         cmd = cmd.split("-", 1)
         path = path.replace("'", "")
         p = subprocess.Popen(
             cmd + [path],
             bufsize=0,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
         return client.SubprocessWrapper(p)
 
 
 class DulwichMockSSHClientTest(CompatTestCase, DulwichClientTestBase):
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
         self.real_vendor = client.get_ssh_vendor
         client.get_ssh_vendor = TestSSHVendor
 
     def tearDown(self):
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
         client.get_ssh_vendor = self.real_vendor
 
     def _client(self):
         return client.SSHGitClient("localhost")
 
     def _build_path(self, path):
         return self.gitroot + path
 
 
 class DulwichSubprocessClientTest(CompatTestCase, DulwichClientTestBase):
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
 
     def tearDown(self):
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
 
     def _client(self):
         return client.SubprocessGitClient()
 
     def _build_path(self, path):
         return self.gitroot + path
 
 
 class GitHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
     """HTTP Request handler that calls out to 'git http-backend'."""
 
     # Make rfile unbuffered -- we need to read one line and then pass
     # the rest to a subprocess, so we can't use buffered input.
     rbufsize = 0
 
     def do_POST(self):
         self.run_backend()
 
     def do_GET(self):
         self.run_backend()
 
     def send_head(self):
         return self.run_backend()
 
     def log_request(self, code="-", size="-"):
         # Let's be quiet, the test suite is noisy enough already
         pass
 
     def run_backend(self):  # noqa: C901
         """Call out to git http-backend."""
         # Based on CGIHTTPServer.CGIHTTPRequestHandler.run_cgi:
         # Copyright (c) 2001-2010 Python Software Foundation;
         # All Rights Reserved
         # Licensed under the Python Software Foundation License.
         rest = self.path
         # find an explicit query string, if present.
         i = rest.rfind("?")
         if i >= 0:
             rest, query = rest[:i], rest[i + 1 :]
         else:
             query = ""
 
         env = copy.deepcopy(os.environ)
         env["SERVER_SOFTWARE"] = self.version_string()
         env["SERVER_NAME"] = self.server.server_name
         env["GATEWAY_INTERFACE"] = "CGI/1.1"
         env["SERVER_PROTOCOL"] = self.protocol_version
         env["SERVER_PORT"] = str(self.server.server_port)
         env["GIT_PROJECT_ROOT"] = self.server.root_path
         env["GIT_HTTP_EXPORT_ALL"] = "1"
         env["REQUEST_METHOD"] = self.command
         uqrest = unquote(rest)
         env["PATH_INFO"] = uqrest
         env["SCRIPT_NAME"] = "/"
         if query:
             env["QUERY_STRING"] = query
         host = self.address_string()
         if host != self.client_address[0]:
             env["REMOTE_HOST"] = host
         env["REMOTE_ADDR"] = self.client_address[0]
         authorization = self.headers.get("authorization")
         if authorization:
             authorization = authorization.split()
             if len(authorization) == 2:
                 import base64
                 import binascii
 
                 env["AUTH_TYPE"] = authorization[0]
                 if authorization[0].lower() == "basic":
                     try:
                         authorization = base64.decodestring(authorization[1])
                     except binascii.Error:
                         pass
                     else:
                         authorization = authorization.split(":")
                         if len(authorization) == 2:
                             env["REMOTE_USER"] = authorization[0]
         # XXX REMOTE_IDENT
         content_type = self.headers.get("content-type")
         if content_type:
             env["CONTENT_TYPE"] = content_type
         length = self.headers.get("content-length")
         if length:
             env["CONTENT_LENGTH"] = length
         referer = self.headers.get("referer")
         if referer:
             env["HTTP_REFERER"] = referer
         accept = []
         for line in self.headers.getallmatchingheaders("accept"):
             if line[:1] in "\t\n\r ":
                 accept.append(line.strip())
             else:
                 accept = accept + line[7:].split(",")
         env["HTTP_ACCEPT"] = ",".join(accept)
         ua = self.headers.get("user-agent")
         if ua:
             env["HTTP_USER_AGENT"] = ua
         co = self.headers.get("cookie")
         if co:
             env["HTTP_COOKIE"] = co
         # XXX Other HTTP_* headers
         # Since we're setting the env in the parent, provide empty
         # values to override previously set values
         for k in (
             "QUERY_STRING",
             "REMOTE_HOST",
             "CONTENT_LENGTH",
             "HTTP_USER_AGENT",
             "HTTP_COOKIE",
             "HTTP_REFERER",
         ):
             env.setdefault(k, "")
 
         self.wfile.write(b"HTTP/1.1 200 Script output follows\r\n")
         self.wfile.write(("Server: %s\r\n" % self.server.server_name).encode("ascii"))
         self.wfile.write(("Date: %s\r\n" % self.date_time_string()).encode("ascii"))
 
         decoded_query = query.replace("+", " ")
 
         try:
             nbytes = int(length)
         except (TypeError, ValueError):
             nbytes = 0
         if self.command.lower() == "post" and nbytes > 0:
             data = self.rfile.read(nbytes)
         else:
             data = None
             env["CONTENT_LENGTH"] = "0"
         # throw away additional data [see bug #427345]
         while select.select([self.rfile._sock], [], [], 0)[0]:
             if not self.rfile._sock.recv(1):
                 break
         args = ["http-backend"]
         if "=" not in decoded_query:
             args.append(decoded_query)
         stdout = run_git_or_fail(args, input=data, env=env, stderr=subprocess.PIPE)
         self.wfile.write(stdout)
 
 
 class HTTPGitServer(http.server.HTTPServer):
 
     allow_reuse_address = True
 
     def __init__(self, server_address, root_path):
         http.server.HTTPServer.__init__(self, server_address, GitHTTPRequestHandler)
         self.root_path = root_path
         self.server_name = "localhost"
 
     def get_url(self):
         return "http://%s:%s/" % (self.server_name, self.server_port)
 
 
 class DulwichHttpClientTest(CompatTestCase, DulwichClientTestBase):
 
     min_git_version = (1, 7, 0, 2)
 
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
         self._httpd = HTTPGitServer(("localhost", 0), self.gitroot)
         self.addCleanup(self._httpd.shutdown)
         threading.Thread(target=self._httpd.serve_forever).start()
         run_git_or_fail(["config", "http.uploadpack", "true"], cwd=self.dest)
         run_git_or_fail(["config", "http.receivepack", "true"], cwd=self.dest)
 
     def tearDown(self):
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
         self._httpd.shutdown()
         self._httpd.socket.close()
 
     def _client(self):
         return client.HttpGitClient(self._httpd.get_url())
 
     def _build_path(self, path):
         return path
 
     def test_archive(self):
         raise SkipTest("exporting archives not supported over http")
diff --git a/dulwich/tests/test_client.py b/dulwich/tests/test_client.py
index b844f5e8..84f8fa6c 100644
--- a/dulwich/tests/test_client.py
+++ b/dulwich/tests/test_client.py
@@ -1,1489 +1,1489 @@
 # test_client.py -- Tests for the git protocol, client side
 # Copyright (C) 2009 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.
 #
 
 from io import BytesIO
 import base64
 import os
 import sys
 import shutil
 import tempfile
 import warnings
 
 from urllib.parse import (
     quote as urlquote,
     urlparse,
 )
 
 import dulwich
 from dulwich import (
     client,
 )
 from dulwich.client import (
     InvalidWants,
     LocalGitClient,
     TraditionalGitClient,
     TCPGitClient,
     SSHGitClient,
     HttpGitClient,
     FetchPackResult,
     ReportStatusParser,
     SendPackError,
     StrangeHostname,
     SubprocessSSHVendor,
     PLinkSSHVendor,
     HangupException,
     GitProtocolError,
     check_wants,
     default_urllib3_manager,
     get_credentials_from_store,
     get_transport_and_path,
     get_transport_and_path_from_url,
     parse_rsync_url,
     _remote_error_from_stderr,
 )
 from dulwich.config import (
     ConfigDict,
 )
 from dulwich.tests import (
     TestCase,
 )
 from dulwich.protocol import (
     TCP_GIT_PORT,
     Protocol,
 )
 from dulwich.pack import (
     pack_objects_to_data,
     write_pack_data,
     write_pack_objects,
 )
 from dulwich.objects import Commit, Tree
 from dulwich.repo import (
     MemoryRepo,
     Repo,
 )
 from dulwich.tests import skipIf
 from dulwich.tests.utils import (
     open_repo,
     tear_down_repo,
     setup_warning_catcher,
 )
 
 
 class DummyClient(TraditionalGitClient):
     def __init__(self, can_read, read, write):
         self.can_read = can_read
         self.read = read
         self.write = write
         TraditionalGitClient.__init__(self)
 
     def _connect(self, service, path):
         return Protocol(self.read, self.write), self.can_read, None
 
 
 class DummyPopen:
     def __init__(self, *args, **kwards):
         self.stdin = BytesIO(b"stdin")
         self.stdout = BytesIO(b"stdout")
         self.stderr = BytesIO(b"stderr")
         self.returncode = 0
         self.args = args
         self.kwargs = kwards
 
     def communicate(self, *args, **kwards):
         return ("Running", "")
 
     def wait(self, *args, **kwards):
         return False
 
 
 # TODO(durin42): add unit-level tests of GitClient
 class GitClientTests(TestCase):
     def setUp(self):
         super(GitClientTests, self).setUp()
         self.rout = BytesIO()
         self.rin = BytesIO()
         self.client = DummyClient(lambda x: True, self.rin.read, self.rout.write)
 
     def test_caps(self):
         agent_cap = ("agent=dulwich/%d.%d.%d" % dulwich.__version__).encode("ascii")
         self.assertEqual(
             set(
                 [
                     b"multi_ack",
                     b"side-band-64k",
                     b"ofs-delta",
                     b"thin-pack",
                     b"multi_ack_detailed",
                     b"shallow",
                     agent_cap,
                 ]
             ),
             set(self.client._fetch_capabilities),
         )
         self.assertEqual(
             set(
                 [
                     b"delete-refs",
                     b"ofs-delta",
                     b"report-status",
                     b"side-band-64k",
                     agent_cap,
                 ]
             ),
             set(self.client._send_capabilities),
         )
 
     def test_archive_ack(self):
         self.rin.write(b"0009NACK\n" b"0000")
         self.rin.seek(0)
         self.client.archive(b"bla", b"HEAD", None, None)
         self.assertEqual(self.rout.getvalue(), b"0011argument HEAD0000")
 
     def test_fetch_empty(self):
         self.rin.write(b"0000")
         self.rin.seek(0)
 
-        def check_heads(heads):
+        def check_heads(heads, **kwargs):
             self.assertEqual(heads, {})
             return []
 
         ret = self.client.fetch_pack(b"/", check_heads, None, None)
         self.assertEqual({}, ret.refs)
         self.assertEqual({}, ret.symrefs)
 
     def test_fetch_pack_ignores_magic_ref(self):
         self.rin.write(
             b"00000000000000000000000000000000000000000000 capabilities^{}"
             b"\x00 multi_ack "
             b"thin-pack side-band side-band-64k ofs-delta shallow no-progress "
             b"include-tag\n"
             b"0000"
         )
         self.rin.seek(0)
 
-        def check_heads(heads):
+        def check_heads(heads, **kwargs):
             self.assertEqual({}, heads)
             return []
 
         ret = self.client.fetch_pack(b"bla", check_heads, None, None, None)
         self.assertEqual({}, ret.refs)
         self.assertEqual({}, ret.symrefs)
         self.assertEqual(self.rout.getvalue(), b"0000")
 
     def test_fetch_pack_none(self):
         self.rin.write(
             b"008855dcc6bf963f922e1ed5c4bbaaefcfacef57b1d7 HEAD\x00multi_ack "
             b"thin-pack side-band side-band-64k ofs-delta shallow no-progress "
             b"include-tag\n"
             b"0000"
         )
         self.rin.seek(0)
-        ret = self.client.fetch_pack(b"bla", lambda heads: [], None, None, None)
+        ret = self.client.fetch_pack(b"bla", lambda heads, **kwargs: [], None, None, None)
         self.assertEqual(
             {b"HEAD": b"55dcc6bf963f922e1ed5c4bbaaefcfacef57b1d7"}, ret.refs
         )
         self.assertEqual({}, ret.symrefs)
         self.assertEqual(self.rout.getvalue(), b"0000")
 
     def test_send_pack_no_sideband64k_with_update_ref_error(self):
         # No side-bank-64k reported by server shouldn't try to parse
         # side band data
         pkts = [
             b"55dcc6bf963f922e1ed5c4bbaaefcfacef57b1d7 capabilities^{}"
             b"\x00 report-status delete-refs ofs-delta\n",
             b"",
             b"unpack ok",
             b"ng refs/foo/bar pre-receive hook declined",
             b"",
         ]
         for pkt in pkts:
             if pkt == b"":
                 self.rin.write(b"0000")
             else:
                 self.rin.write(("%04x" % (len(pkt) + 4)).encode("ascii") + pkt)
         self.rin.seek(0)
 
         tree = Tree()
         commit = Commit()
         commit.tree = tree
         commit.parents = []
         commit.author = commit.committer = b"test user"
         commit.commit_time = commit.author_time = 1174773719
         commit.commit_timezone = commit.author_timezone = 0
         commit.encoding = b"UTF-8"
         commit.message = b"test message"
 
         def update_refs(refs):
             return {
                 b"refs/foo/bar": commit.id,
             }
 
         def generate_pack_data(have, want, ofs_delta=False):
             return pack_objects_to_data(
                 [
                     (commit, None),
                     (tree, ""),
                 ]
             )
 
         result = self.client.send_pack("blah", update_refs, generate_pack_data)
         self.assertEqual(
             {b"refs/foo/bar": "pre-receive hook declined"}, result.ref_status
         )
         self.assertEqual({b"refs/foo/bar": commit.id}, result.refs)
 
     def test_send_pack_none(self):
         # Set ref to current value
         self.rin.write(
             b"0078310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"refs/heads/master\x00 report-status delete-refs "
             b"side-band-64k quiet ofs-delta\n"
             b"0000"
         )
         self.rin.seek(0)
 
         def update_refs(refs):
             return {b"refs/heads/master": b"310ca9477129b8586fa2afc779c1f57cf64bba6c"}
 
         def generate_pack_data(have, want, ofs_delta=False):
             return 0, []
 
         self.client.send_pack(b"/", update_refs, generate_pack_data)
         self.assertEqual(self.rout.getvalue(), b"0000")
 
     def test_send_pack_keep_and_delete(self):
         self.rin.write(
             b"0063310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"refs/heads/master\x00report-status delete-refs ofs-delta\n"
             b"003f310ca9477129b8586fa2afc779c1f57cf64bba6c refs/heads/keepme\n"
             b"0000000eunpack ok\n"
             b"0019ok refs/heads/master\n"
             b"0000"
         )
         self.rin.seek(0)
 
         def update_refs(refs):
             return {b"refs/heads/master": b"0" * 40}
 
         def generate_pack_data(have, want, ofs_delta=False):
             return 0, []
 
         self.client.send_pack(b"/", update_refs, generate_pack_data)
         self.assertEqual(
             self.rout.getvalue(),
             b"008b310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"0000000000000000000000000000000000000000 "
             b"refs/heads/master\x00delete-refs ofs-delta report-status0000",
         )
 
     def test_send_pack_delete_only(self):
         self.rin.write(
             b"0063310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"refs/heads/master\x00report-status delete-refs ofs-delta\n"
             b"0000000eunpack ok\n"
             b"0019ok refs/heads/master\n"
             b"0000"
         )
         self.rin.seek(0)
 
         def update_refs(refs):
             return {b"refs/heads/master": b"0" * 40}
 
         def generate_pack_data(have, want, ofs_delta=False):
             return 0, []
 
         self.client.send_pack(b"/", update_refs, generate_pack_data)
         self.assertEqual(
             self.rout.getvalue(),
             b"008b310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"0000000000000000000000000000000000000000 "
             b"refs/heads/master\x00delete-refs ofs-delta report-status0000",
         )
 
     def test_send_pack_new_ref_only(self):
         self.rin.write(
             b"0063310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"refs/heads/master\x00report-status delete-refs ofs-delta\n"
             b"0000000eunpack ok\n"
             b"0019ok refs/heads/blah12\n"
             b"0000"
         )
         self.rin.seek(0)
 
         def update_refs(refs):
             return {
                 b"refs/heads/blah12": b"310ca9477129b8586fa2afc779c1f57cf64bba6c",
                 b"refs/heads/master": b"310ca9477129b8586fa2afc779c1f57cf64bba6c",
             }
 
         def generate_pack_data(have, want, ofs_delta=False):
             return 0, []
 
         f = BytesIO()
         write_pack_objects(f, {})
         self.client.send_pack("/", update_refs, generate_pack_data)
         self.assertEqual(
             self.rout.getvalue(),
             b"008b0000000000000000000000000000000000000000 "
             b"310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"refs/heads/blah12\x00delete-refs ofs-delta report-status0000"
             + f.getvalue(),
         )
 
     def test_send_pack_new_ref(self):
         self.rin.write(
             b"0064310ca9477129b8586fa2afc779c1f57cf64bba6c "
             b"refs/heads/master\x00 report-status delete-refs ofs-delta\n"
             b"0000000eunpack ok\n"
             b"0019ok refs/heads/blah12\n"
             b"0000"
         )
         self.rin.seek(0)
 
         tree = Tree()
         commit = Commit()
         commit.tree = tree
         commit.parents = []
         commit.author = commit.committer = b"test user"
         commit.commit_time = commit.author_time = 1174773719
         commit.commit_timezone = commit.author_timezone = 0
         commit.encoding = b"UTF-8"
         commit.message = b"test message"
 
         def update_refs(refs):
             return {
                 b"refs/heads/blah12": commit.id,
                 b"refs/heads/master": b"310ca9477129b8586fa2afc779c1f57cf64bba6c",
             }
 
         def generate_pack_data(have, want, ofs_delta=False):
             return pack_objects_to_data(
                 [
                     (commit, None),
                     (tree, b""),
                 ]
             )
 
         f = BytesIO()
         write_pack_data(f, *generate_pack_data(None, None))
         self.client.send_pack(b"/", update_refs, generate_pack_data)
         self.assertEqual(
             self.rout.getvalue(),
             b"008b0000000000000000000000000000000000000000 "
             + commit.id
             + b" refs/heads/blah12\x00delete-refs ofs-delta report-status0000"
             + f.getvalue(),
         )
 
     def test_send_pack_no_deleteref_delete_only(self):
         pkts = [
             b"310ca9477129b8586fa2afc779c1f57cf64bba6c refs/heads/master"
             b"\x00 report-status ofs-delta\n",
             b"",
             b"",
         ]
         for pkt in pkts:
             if pkt == b"":
                 self.rin.write(b"0000")
             else:
                 self.rin.write(("%04x" % (len(pkt) + 4)).encode("ascii") + pkt)
         self.rin.seek(0)
 
         def update_refs(refs):
             return {b"refs/heads/master": b"0" * 40}
 
         def generate_pack_data(have, want, ofs_delta=False):
             return 0, []
 
         result = self.client.send_pack(b"/", update_refs, generate_pack_data)
         self.assertEqual(
             result.ref_status,
             {b"refs/heads/master": "remote does not support deleting refs"},
         )
         self.assertEqual(
             result.refs,
             {b"refs/heads/master": b"310ca9477129b8586fa2afc779c1f57cf64bba6c"},
         )
         self.assertEqual(self.rout.getvalue(), b"0000")
 
 
 class TestGetTransportAndPath(TestCase):
     def test_tcp(self):
         c, path = get_transport_and_path("git://foo.com/bar/baz")
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual("foo.com", c._host)
         self.assertEqual(TCP_GIT_PORT, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_tcp_port(self):
         c, path = get_transport_and_path("git://foo.com:1234/bar/baz")
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual("foo.com", c._host)
         self.assertEqual(1234, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_git_ssh_explicit(self):
         c, path = get_transport_and_path("git+ssh://foo.com/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_explicit(self):
         c, path = get_transport_and_path("ssh://foo.com/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_port_explicit(self):
         c, path = get_transport_and_path("git+ssh://foo.com:1234/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/bar/baz", path)
 
     def test_username_and_port_explicit_unknown_scheme(self):
         c, path = get_transport_and_path("unknown://git@server:7999/dply/stuff.git")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("unknown", c.host)
         self.assertEqual("//git@server:7999/dply/stuff.git", path)
 
     def test_username_and_port_explicit(self):
         c, path = get_transport_and_path("ssh://git@server:7999/dply/stuff.git")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("git", c.username)
         self.assertEqual("server", c.host)
         self.assertEqual(7999, c.port)
         self.assertEqual("/dply/stuff.git", path)
 
     def test_ssh_abspath_doubleslash(self):
         c, path = get_transport_and_path("git+ssh://foo.com//bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("//bar/baz", path)
 
     def test_ssh_port(self):
         c, path = get_transport_and_path("git+ssh://foo.com:1234/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_implicit(self):
         c, path = get_transport_and_path("foo:/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_host(self):
         c, path = get_transport_and_path("foo.com:/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_user_host(self):
         c, path = get_transport_and_path("user@foo.com:/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual("user", c.username)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_relpath(self):
         c, path = get_transport_and_path("foo:bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("bar/baz", path)
 
     def test_ssh_host_relpath(self):
         c, path = get_transport_and_path("foo.com:bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("bar/baz", path)
 
     def test_ssh_user_host_relpath(self):
         c, path = get_transport_and_path("user@foo.com:bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual("user", c.username)
         self.assertEqual("bar/baz", path)
 
     def test_local(self):
         c, path = get_transport_and_path("foo.bar/baz")
         self.assertTrue(isinstance(c, LocalGitClient))
         self.assertEqual("foo.bar/baz", path)
 
     @skipIf(sys.platform != "win32", "Behaviour only happens on windows.")
     def test_local_abs_windows_path(self):
         c, path = get_transport_and_path("C:\\foo.bar\\baz")
         self.assertTrue(isinstance(c, LocalGitClient))
         self.assertEqual("C:\\foo.bar\\baz", path)
 
     def test_error(self):
         # Need to use a known urlparse.uses_netloc URL scheme to get the
         # expected parsing of the URL on Python versions less than 2.6.5
         c, path = get_transport_and_path("prospero://bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
 
     def test_http(self):
         url = "https://github.com/jelmer/dulwich"
         c, path = get_transport_and_path(url)
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("/jelmer/dulwich", path)
 
     def test_http_auth(self):
         url = "https://user:passwd@github.com/jelmer/dulwich"
 
         c, path = get_transport_and_path(url)
 
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("/jelmer/dulwich", path)
         self.assertEqual("user", c._username)
         self.assertEqual("passwd", c._password)
 
     def test_http_auth_with_username(self):
         url = "https://github.com/jelmer/dulwich"
 
         c, path = get_transport_and_path(url, username="user2", password="blah")
 
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("/jelmer/dulwich", path)
         self.assertEqual("user2", c._username)
         self.assertEqual("blah", c._password)
 
     def test_http_auth_with_username_and_in_url(self):
         url = "https://user:passwd@github.com/jelmer/dulwich"
 
         c, path = get_transport_and_path(url, username="user2", password="blah")
 
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("/jelmer/dulwich", path)
         self.assertEqual("user", c._username)
         self.assertEqual("passwd", c._password)
 
     def test_http_no_auth(self):
         url = "https://github.com/jelmer/dulwich"
 
         c, path = get_transport_and_path(url)
 
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("/jelmer/dulwich", path)
         self.assertIs(None, c._username)
         self.assertIs(None, c._password)
 
 
 class TestGetTransportAndPathFromUrl(TestCase):
     def test_tcp(self):
         c, path = get_transport_and_path_from_url("git://foo.com/bar/baz")
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual("foo.com", c._host)
         self.assertEqual(TCP_GIT_PORT, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_tcp_port(self):
         c, path = get_transport_and_path_from_url("git://foo.com:1234/bar/baz")
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual("foo.com", c._host)
         self.assertEqual(1234, c._port)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_explicit(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_port_explicit(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com:1234/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/bar/baz", path)
 
     def test_ssh_homepath(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com/~/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual("/~/bar/baz", path)
 
     def test_ssh_port_homepath(self):
         c, path = get_transport_and_path_from_url("git+ssh://foo.com:1234/~/bar/baz")
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual("foo.com", c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual("/~/bar/baz", path)
 
     def test_ssh_host_relpath(self):
         self.assertRaises(
             ValueError, get_transport_and_path_from_url, "foo.com:bar/baz"
         )
 
     def test_ssh_user_host_relpath(self):
         self.assertRaises(
             ValueError, get_transport_and_path_from_url, "user@foo.com:bar/baz"
         )
 
     def test_local_path(self):
         self.assertRaises(ValueError, get_transport_and_path_from_url, "foo.bar/baz")
 
     def test_error(self):
         # Need to use a known urlparse.uses_netloc URL scheme to get the
         # expected parsing of the URL on Python versions less than 2.6.5
         self.assertRaises(
             ValueError, get_transport_and_path_from_url, "prospero://bar/baz"
         )
 
     def test_http(self):
         url = "https://github.com/jelmer/dulwich"
         c, path = get_transport_and_path_from_url(url)
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("https://github.com", c.get_url(b"/"))
         self.assertEqual("/jelmer/dulwich", path)
 
     def test_http_port(self):
         url = "https://github.com:9090/jelmer/dulwich"
         c, path = get_transport_and_path_from_url(url)
         self.assertEqual("https://github.com:9090", c.get_url(b"/"))
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual("/jelmer/dulwich", path)
 
     def test_file(self):
         c, path = get_transport_and_path_from_url("file:///home/jelmer/foo")
         self.assertTrue(isinstance(c, LocalGitClient))
         self.assertEqual("/home/jelmer/foo", path)
 
 
 class TestSSHVendor(object):
     def __init__(self):
         self.host = None
         self.command = ""
         self.username = None
         self.port = None
         self.password = None
         self.key_filename = None
 
     def run_command(
         self,
         host,
         command,
         username=None,
         port=None,
         password=None,
         key_filename=None,
     ):
         self.host = host
         self.command = command
         self.username = username
         self.port = port
         self.password = password
         self.key_filename = key_filename
 
         class Subprocess:
             pass
 
         setattr(Subprocess, "read", lambda: None)
         setattr(Subprocess, "write", lambda: None)
         setattr(Subprocess, "close", lambda: None)
         setattr(Subprocess, "can_read", lambda: None)
         return Subprocess()
 
 
 class SSHGitClientTests(TestCase):
     def setUp(self):
         super(SSHGitClientTests, self).setUp()
 
         self.server = TestSSHVendor()
         self.real_vendor = client.get_ssh_vendor
         client.get_ssh_vendor = lambda: self.server
 
         self.client = SSHGitClient("git.samba.org")
 
     def tearDown(self):
         super(SSHGitClientTests, self).tearDown()
         client.get_ssh_vendor = self.real_vendor
 
     def test_get_url(self):
         path = "/tmp/repo.git"
         c = SSHGitClient("git.samba.org")
 
         url = c.get_url(path)
         self.assertEqual("ssh://git.samba.org/tmp/repo.git", url)
 
     def test_get_url_with_username_and_port(self):
         path = "/tmp/repo.git"
         c = SSHGitClient("git.samba.org", port=2222, username="user")
 
         url = c.get_url(path)
         self.assertEqual("ssh://user@git.samba.org:2222/tmp/repo.git", url)
 
     def test_default_command(self):
         self.assertEqual(b"git-upload-pack", self.client._get_cmd_path(b"upload-pack"))
 
     def test_alternative_command_path(self):
         self.client.alternative_paths[b"upload-pack"] = b"/usr/lib/git/git-upload-pack"
         self.assertEqual(
             b"/usr/lib/git/git-upload-pack",
             self.client._get_cmd_path(b"upload-pack"),
         )
 
     def test_alternative_command_path_spaces(self):
         self.client.alternative_paths[
             b"upload-pack"
         ] = b"/usr/lib/git/git-upload-pack -ibla"
         self.assertEqual(
             b"/usr/lib/git/git-upload-pack -ibla",
             self.client._get_cmd_path(b"upload-pack"),
         )
 
     def test_connect(self):
         server = self.server
         client = self.client
 
         client.username = b"username"
         client.port = 1337
 
         client._connect(b"command", b"/path/to/repo")
         self.assertEqual(b"username", server.username)
         self.assertEqual(1337, server.port)
         self.assertEqual("git-command '/path/to/repo'", server.command)
 
         client._connect(b"relative-command", b"/~/path/to/repo")
         self.assertEqual("git-relative-command '~/path/to/repo'", server.command)
 
 
 class ReportStatusParserTests(TestCase):
     def test_invalid_pack(self):
         parser = ReportStatusParser()
         parser.handle_packet(b"unpack error - foo bar")
         parser.handle_packet(b"ok refs/foo/bar")
         parser.handle_packet(None)
         self.assertRaises(SendPackError, list, parser.check())
 
     def test_update_refs_error(self):
         parser = ReportStatusParser()
         parser.handle_packet(b"unpack ok")
         parser.handle_packet(b"ng refs/foo/bar need to pull")
         parser.handle_packet(None)
         self.assertEqual([(b"refs/foo/bar", "need to pull")], list(parser.check()))
 
     def test_ok(self):
         parser = ReportStatusParser()
         parser.handle_packet(b"unpack ok")
         parser.handle_packet(b"ok refs/foo/bar")
         parser.handle_packet(None)
         self.assertEqual([(b"refs/foo/bar", None)], list(parser.check()))
 
 
 class LocalGitClientTests(TestCase):
     def test_get_url(self):
         path = "/tmp/repo.git"
         c = LocalGitClient()
 
         url = c.get_url(path)
         self.assertEqual("file:///tmp/repo.git", url)
 
     def test_fetch_into_empty(self):
         c = LocalGitClient()
         t = MemoryRepo()
         s = open_repo("a.git")
         self.addCleanup(tear_down_repo, s)
         self.assertEqual(s.get_refs(), c.fetch(s.path, t).refs)
 
     def test_fetch_empty(self):
         c = LocalGitClient()
         s = open_repo("a.git")
         self.addCleanup(tear_down_repo, s)
         out = BytesIO()
         walker = {}
         ret = c.fetch_pack(
-            s.path, lambda heads: [], graph_walker=walker, pack_data=out.write
+            s.path, lambda heads, **kwargs: [], graph_walker=walker, pack_data=out.write
         )
         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",
             },
             ret.refs,
         )
         self.assertEqual({b"HEAD": b"refs/heads/master"}, ret.symrefs)
         self.assertEqual(
             b"PACK\x00\x00\x00\x02\x00\x00\x00\x00\x02\x9d\x08"
             b"\x82;\xd8\xa8\xea\xb5\x10\xadj\xc7\\\x82<\xfd>\xd3\x1e",
             out.getvalue(),
         )
 
     def test_fetch_pack_none(self):
         c = LocalGitClient()
         s = open_repo("a.git")
         self.addCleanup(tear_down_repo, s)
         out = BytesIO()
         walker = MemoryRepo().get_graph_walker()
         ret = c.fetch_pack(
             s.path,
-            lambda heads: [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
+            lambda heads, **kwargs: [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
             graph_walker=walker,
             pack_data=out.write,
         )
         self.assertEqual({b"HEAD": b"refs/heads/master"}, ret.symrefs)
         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",
             },
             ret.refs,
         )
         # Hardcoding is not ideal, but we'll fix that some other day..
         self.assertTrue(
             out.getvalue().startswith(b"PACK\x00\x00\x00\x02\x00\x00\x00\x07")
         )
 
     def test_send_pack_without_changes(self):
         local = open_repo("a.git")
         self.addCleanup(tear_down_repo, local)
 
         target = open_repo("a.git")
         self.addCleanup(tear_down_repo, target)
 
         self.send_and_verify(b"master", local, target)
 
     def test_send_pack_with_changes(self):
         local = open_repo("a.git")
         self.addCleanup(tear_down_repo, local)
 
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
         with Repo.init_bare(target_path) as target:
             self.send_and_verify(b"master", local, target)
 
     def test_get_refs(self):
         local = open_repo("refs.git")
         self.addCleanup(tear_down_repo, local)
 
         client = LocalGitClient()
         refs = client.get_refs(local.path)
         self.assertDictEqual(local.refs.as_dict(), refs)
 
     def send_and_verify(self, branch, local, target):
         """Send branch from local to remote repository and verify it worked."""
         client = LocalGitClient()
         ref_name = b"refs/heads/" + branch
         result = client.send_pack(
             target.path,
             lambda _: {ref_name: local.refs[ref_name]},
             local.generate_pack_data,
         )
 
         self.assertEqual(local.refs[ref_name], result.refs[ref_name])
         self.assertIs(None, result.agent)
         self.assertEqual({}, result.ref_status)
 
         obj_local = local.get_object(result.refs[ref_name])
         obj_target = target.get_object(result.refs[ref_name])
         self.assertEqual(obj_local, obj_target)
 
 
 class HttpGitClientTests(TestCase):
     def test_get_url(self):
         base_url = "https://github.com/jelmer/dulwich"
         path = "/jelmer/dulwich"
         c = HttpGitClient(base_url)
 
         url = c.get_url(path)
         self.assertEqual("https://github.com/jelmer/dulwich", url)
 
     def test_get_url_bytes_path(self):
         base_url = "https://github.com/jelmer/dulwich"
         path_bytes = b"/jelmer/dulwich"
         c = HttpGitClient(base_url)
 
         url = c.get_url(path_bytes)
         self.assertEqual("https://github.com/jelmer/dulwich", url)
 
     def test_get_url_with_username_and_passwd(self):
         base_url = "https://github.com/jelmer/dulwich"
         path = "/jelmer/dulwich"
         c = HttpGitClient(base_url, username="USERNAME", password="PASSWD")
 
         url = c.get_url(path)
         self.assertEqual("https://github.com/jelmer/dulwich", url)
 
     def test_init_username_passwd_set(self):
         url = "https://github.com/jelmer/dulwich"
 
         c = HttpGitClient(url, config=None, username="user", password="passwd")
         self.assertEqual("user", c._username)
         self.assertEqual("passwd", c._password)
 
         basic_auth = c.pool_manager.headers["authorization"]
         auth_string = "%s:%s" % ("user", "passwd")
         b64_credentials = base64.b64encode(auth_string.encode("latin1"))
         expected_basic_auth = "Basic %s" % b64_credentials.decode("latin1")
         self.assertEqual(basic_auth, expected_basic_auth)
 
     def test_init_no_username_passwd(self):
         url = "https://github.com/jelmer/dulwich"
 
         c = HttpGitClient(url, config=None)
         self.assertIs(None, c._username)
         self.assertIs(None, c._password)
         self.assertNotIn("authorization", c.pool_manager.headers)
 
     def test_from_parsedurl_on_url_with_quoted_credentials(self):
         original_username = "john|the|first"
         quoted_username = urlquote(original_username)
 
         original_password = "Ya#1$2%3"
         quoted_password = urlquote(original_password)
 
         url = "https://{username}:{password}@github.com/jelmer/dulwich".format(
             username=quoted_username, password=quoted_password
         )
 
         c = HttpGitClient.from_parsedurl(urlparse(url))
         self.assertEqual(original_username, c._username)
         self.assertEqual(original_password, c._password)
 
         basic_auth = c.pool_manager.headers["authorization"]
         auth_string = "%s:%s" % (original_username, original_password)
         b64_credentials = base64.b64encode(auth_string.encode("latin1"))
         expected_basic_auth = "Basic %s" % b64_credentials.decode("latin1")
         self.assertEqual(basic_auth, expected_basic_auth)
 
     def test_url_redirect_location(self):
         from urllib3.response import HTTPResponse
 
         test_data = {
             "https://gitlab.com/inkscape/inkscape/": {
                 "redirect_url": "https://gitlab.com/inkscape/inkscape.git/",
                 "refs_data": (
                     b"001e# service=git-upload-pack\n00000032"
                     b"fb2bebf4919a011f0fd7cec085443d0031228e76 "
                     b"HEAD\n0000"
                 ),
             },
             "https://github.com/jelmer/dulwich/": {
                 "redirect_url": "https://github.com/jelmer/dulwich/",
                 "refs_data": (
                     b"001e# service=git-upload-pack\n00000032"
                     b"3ff25e09724aa4d86ea5bca7d5dd0399a3c8bfcf "
                     b"HEAD\n0000"
                 ),
             },
         }
 
         tail = "info/refs?service=git-upload-pack"
 
         # we need to mock urllib3.PoolManager as this test will fail
         # otherwise without an active internet connection
         class PoolManagerMock:
             def __init__(self):
                 self.headers = {}
 
             def request(self, method, url, fields=None, headers=None, redirect=True):
                 base_url = url[: -len(tail)]
                 redirect_base_url = test_data[base_url]["redirect_url"]
                 redirect_url = redirect_base_url + tail
                 headers = {
                     "Content-Type": "application/x-git-upload-pack-advertisement"
                 }
                 body = test_data[base_url]["refs_data"]
                 # urllib3 handles automatic redirection by default
                 status = 200
                 request_url = redirect_url
                 # simulate urllib3 behavior when redirect parameter is False
                 if redirect is False:
                     request_url = url
                     if redirect_base_url != base_url:
                         body = ""
                         headers["location"] = redirect_url
                         status = 301
                 return HTTPResponse(
                     body=body,
                     headers=headers,
                     request_method=method,
                     request_url=request_url,
                     status=status,
                 )
 
         pool_manager = PoolManagerMock()
 
         for base_url in test_data.keys():
             # instantiate HttpGitClient with mocked pool manager
             c = HttpGitClient(base_url, pool_manager=pool_manager, config=None)
             # call method that detects url redirection
             _, _, processed_url = c._discover_references(b"git-upload-pack", base_url)
 
             # send the same request as the method above without redirection
             resp = c.pool_manager.request("GET", base_url + tail, redirect=False)
 
             # check expected behavior of urllib3
             redirect_location = resp.get_redirect_location()
             if resp.status == 200:
                 self.assertFalse(redirect_location)
 
             if redirect_location:
                 # check that url redirection has been correctly detected
                 self.assertEqual(processed_url, redirect_location[: -len(tail)])
             else:
                 # check also the no redirection case
                 self.assertEqual(processed_url, base_url)
 
 
 class TCPGitClientTests(TestCase):
     def test_get_url(self):
         host = "github.com"
         path = "/jelmer/dulwich"
         c = TCPGitClient(host)
 
         url = c.get_url(path)
         self.assertEqual("git://github.com/jelmer/dulwich", url)
 
     def test_get_url_with_port(self):
         host = "github.com"
         path = "/jelmer/dulwich"
         port = 9090
         c = TCPGitClient(host, port=port)
 
         url = c.get_url(path)
         self.assertEqual("git://github.com:9090/jelmer/dulwich", url)
 
 
 class DefaultUrllib3ManagerTest(TestCase):
     def test_no_config(self):
         manager = default_urllib3_manager(config=None)
         self.assertEqual(manager.connection_pool_kw["cert_reqs"], "CERT_REQUIRED")
 
     def test_config_no_proxy(self):
         import urllib3
 
         manager = default_urllib3_manager(config=ConfigDict())
         self.assertNotIsInstance(manager, urllib3.ProxyManager)
         self.assertIsInstance(manager, urllib3.PoolManager)
 
     def test_config_no_proxy_custom_cls(self):
         import urllib3
 
         class CustomPoolManager(urllib3.PoolManager):
             pass
 
         manager = default_urllib3_manager(
             config=ConfigDict(), pool_manager_cls=CustomPoolManager
         )
         self.assertIsInstance(manager, CustomPoolManager)
 
     def test_config_ssl(self):
         config = ConfigDict()
         config.set(b"http", b"sslVerify", b"true")
         manager = default_urllib3_manager(config=config)
         self.assertEqual(manager.connection_pool_kw["cert_reqs"], "CERT_REQUIRED")
 
     def test_config_no_ssl(self):
         config = ConfigDict()
         config.set(b"http", b"sslVerify", b"false")
         manager = default_urllib3_manager(config=config)
         self.assertEqual(manager.connection_pool_kw["cert_reqs"], "CERT_NONE")
 
     def test_config_proxy(self):
         import urllib3
 
         config = ConfigDict()
         config.set(b"http", b"proxy", b"http://localhost:3128/")
         manager = default_urllib3_manager(config=config)
 
         self.assertIsInstance(manager, urllib3.ProxyManager)
         self.assertTrue(hasattr(manager, "proxy"))
         self.assertEqual(manager.proxy.scheme, "http")
         self.assertEqual(manager.proxy.host, "localhost")
         self.assertEqual(manager.proxy.port, 3128)
 
     def test_environment_proxy(self):
         import urllib3
 
         config = ConfigDict()
         os.environ["http_proxy"] = "http://myproxy:8080"
         manager = default_urllib3_manager(config=config)
         self.assertIsInstance(manager, urllib3.ProxyManager)
         self.assertTrue(hasattr(manager, "proxy"))
         self.assertEqual(manager.proxy.scheme, "http")
         self.assertEqual(manager.proxy.host, "myproxy")
         self.assertEqual(manager.proxy.port, 8080)
         del os.environ["http_proxy"]
 
     def test_config_proxy_custom_cls(self):
         import urllib3
 
         class CustomProxyManager(urllib3.ProxyManager):
             pass
 
         config = ConfigDict()
         config.set(b"http", b"proxy", b"http://localhost:3128/")
         manager = default_urllib3_manager(
             config=config, proxy_manager_cls=CustomProxyManager
         )
         self.assertIsInstance(manager, CustomProxyManager)
 
     def test_config_no_verify_ssl(self):
         manager = default_urllib3_manager(config=None, cert_reqs="CERT_NONE")
         self.assertEqual(manager.connection_pool_kw["cert_reqs"], "CERT_NONE")
 
 
 class SubprocessSSHVendorTests(TestCase):
     def setUp(self):
         # Monkey Patch client subprocess popen
         self._orig_popen = dulwich.client.subprocess.Popen
         dulwich.client.subprocess.Popen = DummyPopen
 
     def tearDown(self):
         dulwich.client.subprocess.Popen = self._orig_popen
 
     def test_run_command_dashes(self):
         vendor = SubprocessSSHVendor()
         self.assertRaises(
             StrangeHostname,
             vendor.run_command,
             "--weird-host",
             "git-clone-url",
         )
 
     def test_run_command_password(self):
         vendor = SubprocessSSHVendor()
         self.assertRaises(
             NotImplementedError,
             vendor.run_command,
             "host",
             "git-clone-url",
             password="12345",
         )
 
     def test_run_command_password_and_privkey(self):
         vendor = SubprocessSSHVendor()
         self.assertRaises(
             NotImplementedError,
             vendor.run_command,
             "host",
             "git-clone-url",
             password="12345",
             key_filename="/tmp/id_rsa",
         )
 
     def test_run_command_with_port_username_and_privkey(self):
         expected = [
             "ssh",
             "-x",
             "-p",
             "2200",
             "-i",
             "/tmp/id_rsa",
             "user@host",
             "git-clone-url",
         ]
 
         vendor = SubprocessSSHVendor()
         command = vendor.run_command(
             "host",
             "git-clone-url",
             username="user",
             port="2200",
             key_filename="/tmp/id_rsa",
         )
 
         args = command.proc.args
 
         self.assertListEqual(expected, args[0])
 
 
 class PLinkSSHVendorTests(TestCase):
     def setUp(self):
         # Monkey Patch client subprocess popen
         self._orig_popen = dulwich.client.subprocess.Popen
         dulwich.client.subprocess.Popen = DummyPopen
 
     def tearDown(self):
         dulwich.client.subprocess.Popen = self._orig_popen
 
     def test_run_command_dashes(self):
         vendor = PLinkSSHVendor()
         self.assertRaises(
             StrangeHostname,
             vendor.run_command,
             "--weird-host",
             "git-clone-url",
         )
 
     def test_run_command_password_and_privkey(self):
         vendor = PLinkSSHVendor()
 
         warnings.simplefilter("always", UserWarning)
         self.addCleanup(warnings.resetwarnings)
         warnings_list, restore_warnings = setup_warning_catcher()
         self.addCleanup(restore_warnings)
 
         command = vendor.run_command(
             "host",
             "git-clone-url",
             password="12345",
             key_filename="/tmp/id_rsa",
         )
 
         expected_warning = UserWarning(
             "Invoking PLink with a password exposes the password in the "
             "process list."
         )
 
         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)
             )
 
         args = command.proc.args
 
         if sys.platform == "win32":
             binary = ["plink.exe", "-ssh"]
         else:
             binary = ["plink", "-ssh"]
         expected = binary + [
             "-pw",
             "12345",
             "-i",
             "/tmp/id_rsa",
             "host",
             "git-clone-url",
         ]
         self.assertListEqual(expected, args[0])
 
     def test_run_command_password(self):
         if sys.platform == "win32":
             binary = ["plink.exe", "-ssh"]
         else:
             binary = ["plink", "-ssh"]
         expected = binary + ["-pw", "12345", "host", "git-clone-url"]
 
         vendor = PLinkSSHVendor()
 
         warnings.simplefilter("always", UserWarning)
         self.addCleanup(warnings.resetwarnings)
         warnings_list, restore_warnings = setup_warning_catcher()
         self.addCleanup(restore_warnings)
 
         command = vendor.run_command("host", "git-clone-url", password="12345")
 
         expected_warning = UserWarning(
             "Invoking PLink with a password exposes the password in the "
             "process list."
         )
 
         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)
             )
 
         args = command.proc.args
 
         self.assertListEqual(expected, args[0])
 
     def test_run_command_with_port_username_and_privkey(self):
         if sys.platform == "win32":
             binary = ["plink.exe", "-ssh"]
         else:
             binary = ["plink", "-ssh"]
         expected = binary + [
             "-P",
             "2200",
             "-i",
             "/tmp/id_rsa",
             "user@host",
             "git-clone-url",
         ]
 
         vendor = PLinkSSHVendor()
         command = vendor.run_command(
             "host",
             "git-clone-url",
             username="user",
             port="2200",
             key_filename="/tmp/id_rsa",
         )
 
         args = command.proc.args
 
         self.assertListEqual(expected, args[0])
 
 
 class RsyncUrlTests(TestCase):
     def test_simple(self):
         self.assertEqual(parse_rsync_url("foo:bar/path"), (None, "foo", "bar/path"))
         self.assertEqual(
             parse_rsync_url("user@foo:bar/path"), ("user", "foo", "bar/path")
         )
 
     def test_path(self):
         self.assertRaises(ValueError, parse_rsync_url, "/path")
 
 
 class CheckWantsTests(TestCase):
     def test_fine(self):
         check_wants(
             [b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262"],
             {b"refs/heads/blah": b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262"},
         )
 
     def test_missing(self):
         self.assertRaises(
             InvalidWants,
             check_wants,
             [b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262"],
             {b"refs/heads/blah": b"3f3dc7a53fb752a6961d3a56683df46d4d3bf262"},
         )
 
     def test_annotated(self):
         self.assertRaises(
             InvalidWants,
             check_wants,
             [b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262"],
             {
                 b"refs/heads/blah": b"3f3dc7a53fb752a6961d3a56683df46d4d3bf262",
                 b"refs/heads/blah^{}": b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262",
             },
         )
 
 
 class FetchPackResultTests(TestCase):
     def test_eq(self):
         self.assertEqual(
             FetchPackResult(
                 {b"refs/heads/master": b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262"},
                 {},
                 b"user/agent",
             ),
             FetchPackResult(
                 {b"refs/heads/master": b"2f3dc7a53fb752a6961d3a56683df46d4d3bf262"},
                 {},
                 b"user/agent",
             ),
         )
 
 
 class GitCredentialStoreTests(TestCase):
     @classmethod
     def setUpClass(cls):
         with tempfile.NamedTemporaryFile(delete=False) as f:
             f.write(b"https://user:pass@example.org\n")
         cls.fname = f.name
 
     @classmethod
     def tearDownClass(cls):
         os.unlink(cls.fname)
 
     def test_nonmatching_scheme(self):
         self.assertEqual(
             get_credentials_from_store(b"http", b"example.org", fnames=[self.fname]),
             None,
         )
 
     def test_nonmatching_hostname(self):
         self.assertEqual(
             get_credentials_from_store(b"https", b"noentry.org", fnames=[self.fname]),
             None,
         )
 
     def test_match_without_username(self):
         self.assertEqual(
             get_credentials_from_store(b"https", b"example.org", fnames=[self.fname]),
             (b"user", b"pass"),
         )
 
     def test_match_with_matching_username(self):
         self.assertEqual(
             get_credentials_from_store(
                 b"https", b"example.org", b"user", fnames=[self.fname]
             ),
             (b"user", b"pass"),
         )
 
     def test_no_match_with_nonmatching_username(self):
         self.assertEqual(
             get_credentials_from_store(
                 b"https", b"example.org", b"otheruser", fnames=[self.fname]
             ),
             None,
         )
 
 
 class RemoteErrorFromStderrTests(TestCase):
     def test_nothing(self):
         self.assertEqual(_remote_error_from_stderr(None), HangupException())
 
     def test_error_line(self):
         b = BytesIO(
             b"""\
 This is some random output.
 ERROR: This is the actual error
 with a tail
 """
         )
         self.assertEqual(
             _remote_error_from_stderr(b),
             GitProtocolError("This is the actual error"),
         )
 
     def test_no_error_line(self):
         b = BytesIO(
             b"""\
 This is output without an error line.
 And this line is just random noise, too.
 """
         )
         self.assertEqual(
             _remote_error_from_stderr(b),
             HangupException(
                 [
                     b"This is output without an error line.",
                     b"And this line is just random noise, too.",
                 ]
             ),
         )
diff --git a/dulwich/tests/test_object_store.py b/dulwich/tests/test_object_store.py
index 0b11c023..2e416cff 100644
--- a/dulwich/tests/test_object_store.py
+++ b/dulwich/tests/test_object_store.py
@@ -1,735 +1,784 @@
 # 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 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_corrupted_object_raise_exception(self):
         """Corrupted sha1 disk file should raise specific exception"""
         self.store.add_object(testobject)
         self.assertEqual(
             (Blob.type_num, b"yummy data"), self.store.get_raw(testobject.id)
         )
         self.assertTrue(self.store.contains_loose(testobject.id))
         self.assertIsNotNone(self.store._get_loose_object(testobject.id))
 
         path = self.store._get_shafile_path(testobject.id)
         with open(path, "wb") as f:  # corrupt the file
             f.write(b"")
 
         expected_error_msg = "Corrupted empty file detected"
         try:
             self.store.contains_loose(testobject.id)
         except EmptyFileException as e:
             self.assertEqual(str(e), expected_error_msg)
 
         try:
             self.store._get_loose_object(testobject.id)
         except EmptyFileException as e:
             self.assertEqual(str(e), expected_error_msg)
 
         # this does not change iteration on loose objects though
         self.assertEqual([testobject.id], list(self.store._iter_loose_objects()))
 
     def test_tempfile_in_loose_store(self):
         self.store.add_object(testobject)
         self.assertEqual([testobject.id], list(self.store._iter_loose_objects()))
 
         # add temporary files to the loose store
         for i in range(256):
             dirname = os.path.join(self.store_dir, "%02x" % i)
             if not os.path.isdir(dirname):
                 os.makedirs(dirname)
             fd, n = tempfile.mkstemp(prefix="tmp_obj_", dir=dirname)
             os.close(fd)
 
         self.assertEqual([testobject.id], list(self.store._iter_loose_objects()))
 
     def test_add_alternate_path(self):
         store = DiskObjectStore(self.store_dir)
         self.assertEqual([], list(store._read_alternate_paths()))
         store.add_alternate_path("/foo/path")
         self.assertEqual(["/foo/path"], list(store._read_alternate_paths()))
         store.add_alternate_path("/bar/path")
         self.assertEqual(
             ["/foo/path", "/bar/path"], list(store._read_alternate_paths())
         )
 
     def test_rel_alternative_path(self):
         alternate_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, alternate_dir)
         alternate_store = DiskObjectStore(alternate_dir)
         b2 = make_object(Blob, data=b"yummy data")
         alternate_store.add_object(b2)
         store = DiskObjectStore(self.store_dir)
         self.assertRaises(KeyError, store.__getitem__, b2.id)
         store.add_alternate_path(os.path.relpath(alternate_dir, self.store_dir))
         self.assertEqual(list(alternate_store), list(store.alternates[0]))
         self.assertIn(b2.id, store)
         self.assertEqual(b2, store[b2.id])
 
     def test_pack_dir(self):
         o = DiskObjectStore(self.store_dir)
         self.assertEqual(os.path.join(self.store_dir, "pack"), o.pack_dir)
 
     def test_add_pack(self):
         o = DiskObjectStore(self.store_dir)
         f, commit, abort = o.add_pack()
         try:
             b = make_object(Blob, data=b"more yummy data")
             write_pack_objects(f, [(b, None)])
         except BaseException:
             abort()
             raise
         else:
             commit()
 
     def test_add_thin_pack(self):
         o = DiskObjectStore(self.store_dir)
         try:
             blob = make_object(Blob, data=b"yummy data")
             o.add_object(blob)
 
             f = BytesIO()
             entries = build_pack(
                 f,
                 [
                     (REF_DELTA, (blob.id, b"more yummy data")),
                 ],
                 store=o,
             )
 
             with o.add_thin_pack(f.read, None) as pack:
                 packed_blob_sha = sha_to_hex(entries[0][3])
                 pack.check_length_and_checksum()
                 self.assertEqual(sorted([blob.id, packed_blob_sha]), list(pack))
                 self.assertTrue(o.contains_packed(packed_blob_sha))
                 self.assertTrue(o.contains_packed(blob.id))
                 self.assertEqual(
                     (Blob.type_num, b"more yummy data"),
                     o.get_raw(packed_blob_sha),
                 )
         finally:
             o.close()
 
     def test_add_thin_pack_empty(self):
         with closing(DiskObjectStore(self.store_dir)) as o:
             f = BytesIO()
             entries = build_pack(f, [], store=o)
             self.assertEqual([], entries)
             o.add_thin_pack(f.read, None)
 
 
 class TreeLookupPathTests(TestCase):
     def setUp(self):
         TestCase.setUp(self)
         self.store = MemoryObjectStore()
         blob_a = make_object(Blob, data=b"a")
         blob_b = make_object(Blob, data=b"b")
         blob_c = make_object(Blob, data=b"c")
         for blob in [blob_a, blob_b, blob_c]:
             self.store.add_object(blob)
 
         blobs = [
             (b"a", blob_a.id, 0o100644),
             (b"ad/b", blob_b.id, 0o100644),
             (b"ad/bd/c", blob_c.id, 0o100755),
             (b"ad/c", blob_c.id, 0o100644),
             (b"c", blob_c.id, 0o100644),
         ]
         self.tree_id = commit_tree(self.store, blobs)
 
     def get_object(self, sha):
         return self.store[sha]
 
     def test_lookup_blob(self):
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"a")[1]
         self.assertTrue(isinstance(self.store[o_id], Blob))
 
     def test_lookup_tree(self):
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad")[1]
         self.assertTrue(isinstance(self.store[o_id], Tree))
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd")[1]
         self.assertTrue(isinstance(self.store[o_id], Tree))
         o_id = tree_lookup_path(self.get_object, self.tree_id, b"ad/bd/")[1]
         self.assertTrue(isinstance(self.store[o_id], Tree))
 
     def test_lookup_nonexistent(self):
         self.assertRaises(
             KeyError, tree_lookup_path, self.get_object, self.tree_id, b"j"
         )
 
     def test_lookup_not_tree(self):
         self.assertRaises(
             NotTreeError,
             tree_lookup_path,
             self.get_object,
             self.tree_id,
             b"ad/b/j",
         )
 
 
 class ObjectStoreGraphWalkerTests(TestCase):
     def get_walker(self, heads, parent_map):
         new_parent_map = dict(
             [(k * 40, [(p * 40) for p in ps]) for (k, ps) in parent_map.items()]
         )
         return ObjectStoreGraphWalker(
             [x * 40 for x in heads], new_parent_map.__getitem__
         )
 
     def test_ack_invalid_value(self):
         gw = self.get_walker([], {})
         self.assertRaises(ValueError, gw.ack, "tooshort")
 
     def test_empty(self):
         gw = self.get_walker([], {})
         self.assertIs(None, next(gw))
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_descends(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
         self.assertEqual(b"a" * 40, next(gw))
         self.assertEqual(b"b" * 40, next(gw))
 
     def test_present(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_parent_present(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": []})
         self.assertEqual(b"a" * 40, next(gw))
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_child_ack_later(self):
         gw = self.get_walker([b"a"], {b"a": [b"b"], b"b": [b"c"], b"c": []})
         self.assertEqual(b"a" * 40, next(gw))
         self.assertEqual(b"b" * 40, next(gw))
         gw.ack(b"a" * 40)
         self.assertIs(None, next(gw))
 
     def test_only_once(self):
         # a  b
         # |  |
         # c  d
         # \ /
         #  e
         gw = self.get_walker(
             [b"a", b"b"],
             {
                 b"a": [b"c"],
                 b"b": [b"d"],
                 b"c": [b"e"],
                 b"d": [b"e"],
                 b"e": [],
             },
         )
         walk = []
         acked = False
         walk.append(next(gw))
         walk.append(next(gw))
         # A branch (a, c) or (b, d) may be done after 2 steps or 3 depending on
         # the order walked: 3-step walks include (a, b, c) and (b, a, d), etc.
         if walk == [b"a" * 40, b"c" * 40] or walk == [b"b" * 40, b"d" * 40]:
             gw.ack(walk[0])
             acked = True
 
         walk.append(next(gw))
         if not acked and walk[2] == b"c" * 40:
             gw.ack(b"a" * 40)
         elif not acked and walk[2] == b"d" * 40:
             gw.ack(b"b" * 40)
         walk.append(next(gw))
         self.assertIs(None, next(gw))
 
         self.assertEqual([b"a" * 40, b"b" * 40, b"c" * 40, b"d" * 40], sorted(walk))
         self.assertLess(walk.index(b"a" * 40), walk.index(b"c" * 40))
         self.assertLess(walk.index(b"b" * 40), walk.index(b"d" * 40))
 
 
 class CommitTreeChangesTests(TestCase):
     def setUp(self):
         super(CommitTreeChangesTests, self).setUp()
         self.store = MemoryObjectStore()
         self.blob_a = make_object(Blob, data=b"a")
         self.blob_b = make_object(Blob, data=b"b")
         self.blob_c = make_object(Blob, data=b"c")
         for blob in [self.blob_a, self.blob_b, self.blob_c]:
             self.store.add_object(blob)
 
         blobs = [
             (b"a", self.blob_a.id, 0o100644),
             (b"ad/b", self.blob_b.id, 0o100644),
             (b"ad/bd/c", self.blob_c.id, 0o100755),
             (b"ad/c", self.blob_c.id, 0o100644),
             (b"c", self.blob_c.id, 0o100644),
         ]
         self.tree_id = commit_tree(self.store, blobs)
 
     def test_no_changes(self):
         self.assertEqual(
             self.store[self.tree_id],
             commit_tree_changes(self.store, self.store[self.tree_id], []),
         )
 
     def test_add_blob(self):
         blob_d = make_object(Blob, data=b"d")
         new_tree = commit_tree_changes(
             self.store, self.store[self.tree_id], [(b"d", 0o100644, blob_d.id)]
         )
         self.assertEqual(
             new_tree[b"d"],
             (33188, b"c59d9b6344f1af00e504ba698129f07a34bbed8d"),
         )
 
     def test_add_blob_in_dir(self):
         blob_d = make_object(Blob, data=b"d")
         new_tree = commit_tree_changes(
             self.store,
             self.store[self.tree_id],
             [(b"e/f/d", 0o100644, blob_d.id)],
         )
         self.assertEqual(
             new_tree.items(),
             [
                 TreeEntry(path=b"a", mode=stat.S_IFREG | 0o100644, sha=self.blob_a.id),
                 TreeEntry(
                     path=b"ad",
                     mode=stat.S_IFDIR,
                     sha=b"0e2ce2cd7725ff4817791be31ccd6e627e801f4a",
                 ),
                 TreeEntry(path=b"c", mode=stat.S_IFREG | 0o100644, sha=self.blob_c.id),
                 TreeEntry(
                     path=b"e",
                     mode=stat.S_IFDIR,
                     sha=b"6ab344e288724ac2fb38704728b8896e367ed108",
                 ),
             ],
         )
         e_tree = self.store[new_tree[b"e"][1]]
         self.assertEqual(
             e_tree.items(),
             [
                 TreeEntry(
                     path=b"f",
                     mode=stat.S_IFDIR,
                     sha=b"24d2c94d8af232b15a0978c006bf61ef4479a0a5",
                 )
             ],
         )
         f_tree = self.store[e_tree[b"f"][1]]
         self.assertEqual(
             f_tree.items(),
             [TreeEntry(path=b"d", mode=stat.S_IFREG | 0o100644, sha=blob_d.id)],
         )
 
     def test_delete_blob(self):
         new_tree = commit_tree_changes(
             self.store, self.store[self.tree_id], [(b"ad/bd/c", None, None)]
         )
         self.assertEqual(set(new_tree), {b"a", b"ad", b"c"})
         ad_tree = self.store[new_tree[b"ad"][1]]
         self.assertEqual(set(ad_tree), {b"b", b"c"})
 
 
 class TestReadPacksFile(TestCase):
     def test_read_packs(self):
         self.assertEqual(
             ["pack-1.pack"],
             list(
                 read_packs_file(
                     BytesIO(
                         b"""P pack-1.pack
 """
                     )
                 )
             ),
         )
diff --git a/dulwich/tests/test_repository.py b/dulwich/tests/test_repository.py
index 48aae552..9495d2f1 100644
--- a/dulwich/tests/test_repository.py
+++ b/dulwich/tests/test_repository.py
@@ -1,1268 +1,1276 @@
 # -*- 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 locale
 import os
 import stat
 import shutil
 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)
 
     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<>"
         )