git: a little pycompat.bytestring() love to make this code work in py3

Differential Revision: https://phab.mercurial-scm.org/D5765

contrib/python3-whitelist

@@ -1,747 +1,748 b''
 test-abort-checkin.t
 test-absorb-edit-lines.t
 test-absorb-filefixupstate.py
 test-absorb-phase.t
 test-absorb-rename.t
 test-absorb-strip.t
 test-absorb.t
 test-add.t
 test-addremove-similar.t
 test-addremove.t
 test-alias.t
 test-amend-subrepo.t
 test-amend.t
 test-ancestor.py
 test-annotate.py
 test-annotate.t
 test-arbitraryfilectx.t
 test-archive-symlinks.t
 test-archive.t
 test-atomictempfile.py
 test-audit-path.t
 test-audit-subrepo.t
 test-automv.t
 test-backout.t
 test-backwards-remove.t
 test-bad-extension.t
 test-bad-pull.t
 test-basic.t
 test-batching.py
 test-bdiff.py
 test-bheads.t
 test-bisect.t
 test-bisect2.t
 test-bisect3.t
 test-blackbox.t
 test-bookflow.t
 test-bookmarks-current.t
 test-bookmarks-merge.t
 test-bookmarks-pushpull.t
 test-bookmarks-rebase.t
 test-bookmarks-strip.t
 test-bookmarks.t
 test-branch-change.t
 test-branch-option.t
 test-branch-tag-confict.t
 test-branches.t
 test-bugzilla.t
 test-bundle-phases.t
 test-bundle-r.t
 test-bundle-type.t
 test-bundle-vs-outgoing.t
 test-bundle.t
 test-bundle2-exchange.t
 test-bundle2-format.t
 test-bundle2-multiple-changegroups.t
 test-bundle2-pushback.t
 test-bundle2-remote-changegroup.t
 test-cache-abuse.t
 test-cappedreader.py
 test-casecollision-merge.t
 test-casecollision.t
 test-casefolding.t
 test-cat.t
 test-cbor.py
 test-censor.t
 test-changelog-exec.t
 test-check-code.t
 test-check-commit.t
 test-check-config.py
 test-check-config.t
 test-check-execute.t
 test-check-help.t
 test-check-interfaces.py
 test-check-module-imports.t
 test-check-py3-compat.t
 test-check-pyflakes.t
 test-check-pylint.t
 test-check-shbang.t
 test-children.t
 test-churn.t
 test-clone-cgi.t
 test-clone-pull-corruption.t
 test-clone-r.t
 test-clone-uncompressed.t
 test-clone-update-order.t
 test-clone.t
 test-clonebundles.t
 test-close-head.t
 test-commandserver.t
 test-commit-amend.t
 test-commit-interactive.t
 test-commit-multiple.t
 test-commit-unresolved.t
 test-commit.t
 test-committer.t
 test-completion.t
 test-config-env.py
 test-config.t
 test-conflict.t
 test-confused-revert.t
 test-context-metadata.t
 test-context.py
 test-contrib-check-code.t
 test-contrib-check-commit.t
 test-contrib-dumprevlog.t
 test-contrib-perf.t
 test-contrib-relnotes.t
 test-contrib-testparseutil.t
 test-contrib.t
 test-convert-authormap.t
 test-convert-clonebranches.t
 test-convert-cvs-branch.t
 test-convert-cvs-detectmerge.t
 test-convert-cvs-synthetic.t
 test-convert-cvs.t
 test-convert-cvsnt-mergepoints.t
 test-convert-datesort.t
 test-convert-filemap.t
+test-convert-git.t
 test-convert-hg-sink.t
 test-convert-hg-source.t
 test-convert-hg-startrev.t
 test-convert-splicemap.t
 test-convert-svn-sink.t
 test-convert-tagsbranch-topology.t
 test-convert.t
 test-copy-move-merge.t
 test-copy.t
 test-copytrace-heuristics.t
 test-custom-filters.t
 test-debugbuilddag.t
 test-debugbundle.t
 test-debugcommands.t
 test-debugextensions.t
 test-debugindexdot.t
 test-debugrename.t
 test-default-push.t
 test-diff-antipatience.t
 test-diff-binary-file.t
 test-diff-change.t
 test-diff-color.t
 test-diff-copy-depth.t
 test-diff-hashes.t
 test-diff-ignore-whitespace.t
 test-diff-indent-heuristic.t
 test-diff-issue2761.t
 test-diff-newlines.t
 test-diff-reverse.t
 test-diff-subdir.t
 test-diff-unified.t
 test-diff-upgrade.t
 test-diffdir.t
 test-diffstat.t
 test-directaccess.t
 test-dirstate-backup.t
 test-dirstate-nonnormalset.t
 test-dirstate-race.t
 test-dirstate.t
 test-dispatch.py
 test-dispatch.t
 test-doctest.py
 test-double-merge.t
 test-drawdag.t
 test-duplicateoptions.py
 test-editor-filename.t
 test-empty-dir.t
 test-empty-file.t
 test-empty-group.t
 test-empty.t
 test-encode.t
 test-encoding-align.t
 test-encoding-func.py
 test-encoding-textwrap.t
 test-encoding.t
 test-eol-add.t
 test-eol-clone.t
 test-eol-hook.t
 test-eol-patch.t
 test-eol-tag.t
 test-eol-update.t
 test-eol.t
 test-eolfilename.t
 test-excessive-merge.t
 test-exchange-obsmarkers-case-A1.t
 test-exchange-obsmarkers-case-A2.t
 test-exchange-obsmarkers-case-A3.t
 test-exchange-obsmarkers-case-A4.t
 test-exchange-obsmarkers-case-A5.t
 test-exchange-obsmarkers-case-A6.t
 test-exchange-obsmarkers-case-A7.t
 test-exchange-obsmarkers-case-B1.t
 test-exchange-obsmarkers-case-B2.t
 test-exchange-obsmarkers-case-B3.t
 test-exchange-obsmarkers-case-B4.t
 test-exchange-obsmarkers-case-B5.t
 test-exchange-obsmarkers-case-B6.t
 test-exchange-obsmarkers-case-B7.t
 test-exchange-obsmarkers-case-C1.t
 test-exchange-obsmarkers-case-C2.t
 test-exchange-obsmarkers-case-C3.t
 test-exchange-obsmarkers-case-C4.t
 test-exchange-obsmarkers-case-D1.t
 test-exchange-obsmarkers-case-D2.t
 test-exchange-obsmarkers-case-D3.t
 test-exchange-obsmarkers-case-D4.t
 test-execute-bit.t
 test-export.t
 test-extdata.t
 test-extdiff.t
 test-extension-timing.t
 test-extensions-afterloaded.t
 test-extensions-wrapfunction.py
 test-extra-filelog-entry.t
 test-fastannotate-corrupt.t
 test-fastannotate-diffopts.t
 test-fastannotate-hg.t
 test-fastannotate-perfhack.t
 test-fastannotate-protocol.t
 test-fastannotate-renames.t
 test-fastannotate-revmap.py
 test-fastannotate.t
 test-fetch.t
 test-filebranch.t
 test-filecache.py
 test-filelog.py
 test-fileset-generated.t
 test-fileset.t
 test-fix-topology.t
 test-fix.t
 test-flags.t
 test-fncache.t
 test-gendoc-da.t
 test-gendoc-de.t
 test-gendoc-el.t
 test-gendoc-fr.t
 test-gendoc-it.t
 test-gendoc-ja.t
 test-gendoc-pt_BR.t
 test-gendoc-ro.t
 test-gendoc-ru.t
 test-gendoc-sv.t
 test-gendoc-zh_CN.t
 test-gendoc-zh_TW.t
 test-gendoc.t
 test-generaldelta.t
 test-getbundle.t
 test-git-export.t
 test-githelp.t
 test-globalopts.t
 test-glog-beautifygraph.t
 test-glog-topological.t
 test-glog.t
 test-gpg.t
 test-graft.t
 test-grep.t
 test-hardlinks.t
 test-help-hide.t
 test-help.t
 test-hg-parseurl.py
 test-hghave.t
 test-hgignore.t
 test-hgk.t
 test-hgrc.t
 test-hgweb-annotate-whitespace.t
 test-hgweb-auth.py
 test-hgweb-bundle.t
 test-hgweb-commands.t
 test-hgweb-csp.t
 test-hgweb-descend-empties.t
 test-hgweb-diffs.t
 test-hgweb-empty.t
 test-hgweb-filelog.t
 test-hgweb-no-path-info.t
 test-hgweb-no-request-uri.t
 test-hgweb-non-interactive.t
 test-hgweb-raw.t
 test-hgweb-removed.t
 test-hgweb-symrev.t
 test-hgweb.t
 test-hgwebdir-paths.py
 test-hgwebdir.t
 test-hgwebdirsym.t
 test-histedit-arguments.t
 test-histedit-base.t
 test-histedit-bookmark-motion.t
 test-histedit-commute.t
 test-histedit-drop.t
 test-histedit-edit.t
 test-histedit-fold-non-commute.t
 test-histedit-fold.t
 test-histedit-no-backup.t
 test-histedit-no-change.t
 test-histedit-non-commute-abort.t
 test-histedit-non-commute.t
 test-histedit-obsolete.t
 test-histedit-outgoing.t
 test-histedit-templates.t
 test-http-api-httpv2.t
 test-http-api.t
 test-http-bad-server.t
 test-http-branchmap.t
 test-http-bundle1.t
 test-http-clone-r.t
 test-http-permissions.t
 test-http-protocol.t
 test-http.t
 test-hybridencode.py
 test-i18n.t
 test-identify.t
 test-impexp-branch.t
 test-import-bypass.t
 test-import-context.t
 test-import-eol.t
 test-import-merge.t
 test-import-unknown.t
 test-import.t
 test-imports-checker.t
 test-incoming-outgoing.t
 test-infinitepush-bundlestore.t
 test-infinitepush-ci.t
 test-infinitepush.t
 test-inherit-mode.t
 test-init.t
 test-install.t
 test-issue1089.t
 test-issue1102.t
 test-issue1175.t
 test-issue1306.t
 test-issue1438.t
 test-issue1502.t
 test-issue1802.t
 test-issue1877.t
 test-issue1993.t
 test-issue2137.t
 test-issue3084.t
 test-issue4074.t
 test-issue522.t
 test-issue586.t
 test-issue5979.t
 test-issue612.t
 test-issue619.t
 test-issue660.t
 test-issue672.t
 test-issue842.t
 test-journal-exists.t
 test-journal-share.t
 test-journal.t
 test-keyword.t
 test-known.t
 test-largefiles-cache.t
 test-largefiles-misc.t
 test-largefiles-small-disk.t
 test-largefiles-update.t
 test-largefiles-wireproto.t
 test-largefiles.t
 test-lfconvert.t
 test-lfs-bundle.t
 test-lfs-largefiles.t
 test-lfs-pointer.py
 test-lfs-test-server.t
 test-lfs.t
 test-linelog.py
 test-linerange.py
 test-locate.t
 test-lock-badness.t
 test-log-exthook.t
 test-log-linerange.t
 test-log.t
 test-logexchange.t
 test-logtoprocess.t
 test-lrucachedict.py
 test-mactext.t
 test-mailmap.t
 test-manifest-merging.t
 test-manifest.py
 test-manifest.t
 test-match.py
 test-mdiff.py
 test-merge-changedelete.t
 test-merge-closedheads.t
 test-merge-commit.t
 test-merge-criss-cross.t
 test-merge-default.t
 test-merge-force.t
 test-merge-halt.t
 test-merge-internal-tools-pattern.t
 test-merge-local.t
 test-merge-no-file-change.t
 test-merge-remove.t
 test-merge-revert.t
 test-merge-revert2.t
 test-merge-subrepos.t
 test-merge-symlinks.t
 test-merge-tools.t
 test-merge-types.t
 test-merge1.t
 test-merge10.t
 test-merge2.t
 test-merge4.t
 test-merge5.t
 test-merge6.t
 test-merge7.t
 test-merge8.t
 test-merge9.t
 test-minifileset.py
 test-minirst.py
 test-missing-capability.t
 test-mq-eol.t
 test-mq-git.t
 test-mq-guards.t
 test-mq-header-date.t
 test-mq-header-from.t
 test-mq-merge.t
 test-mq-missingfiles.t
 test-mq-pull-from-bundle.t
 test-mq-qclone-http.t
 test-mq-qdelete.t
 test-mq-qdiff.t
 test-mq-qfold.t
 test-mq-qgoto.t
 test-mq-qimport-fail-cleanup.t
 test-mq-qimport.t
 test-mq-qnew.t
 test-mq-qpush-exact.t
 test-mq-qpush-fail.t
 test-mq-qqueue.t
 test-mq-qrefresh-interactive.t
 test-mq-qrefresh-replace-log-message.t
 test-mq-qrefresh.t
 test-mq-qrename.t
 test-mq-qsave.t
 test-mq-safety.t
 test-mq-subrepo.t
 test-mq-symlinks.t
 test-mq.t
 test-mv-cp-st-diff.t
 test-narrow-acl.t
 test-narrow-archive.t
 test-narrow-clone-no-ellipsis.t
 test-narrow-clone-non-narrow-server.t
 test-narrow-clone-nonlinear.t
 test-narrow-clone-stream.t
 test-narrow-clone.t
 test-narrow-commit.t
 test-narrow-copies.t
 test-narrow-debugcommands.t
 test-narrow-debugrebuilddirstate.t
 test-narrow-exchange-merges.t
 test-narrow-exchange.t
 test-narrow-expanddirstate.t
 test-narrow-merge.t
 test-narrow-patch.t
 test-narrow-patterns.t
 test-narrow-pull.t
 test-narrow-rebase.t
 test-narrow-shallow-merges.t
 test-narrow-shallow.t
 test-narrow-share.t
 test-narrow-sparse.t
 test-narrow-strip.t
 test-narrow-trackedcmd.t
 test-narrow-update.t
 test-narrow-widen-no-ellipsis.t
 test-narrow-widen.t
 test-narrow.t
 test-nested-repo.t
 test-newbranch.t
 test-newcgi.t
 test-newercgi.t
 test-nointerrupt.t
 test-notify-changegroup.t
 test-obshistory.t
 test-obsmarker-template.t
 test-obsmarkers-effectflag.t
 test-obsolete-bounds-checking.t
 test-obsolete-bundle-strip.t
 test-obsolete-changeset-exchange.t
 test-obsolete-checkheads.t
 test-obsolete-distributed.t
 test-obsolete-divergent.t
 test-obsolete-tag-cache.t
 test-obsolete.t
 test-oldcgi.t
 test-origbackup-conflict.t
 test-pager-legacy.t
 test-pager.t
 test-parents.t
 test-parse-date.t
 test-parseindex.t
 test-parseindex2.py
 test-patch-offset.t
 test-patch.t
 test-patchbomb-bookmark.t
 test-patchbomb-tls.t
 test-patchbomb.t
 test-pathconflicts-basic.t
 test-pathconflicts-merge.t
 test-pathconflicts-update.t
 test-pathencode.py
 test-pending.t
 test-permissions.t
 test-phases-exchange.t
 test-phases.t
 test-profile.t
 test-progress.t
 test-propertycache.py
 test-pull-branch.t
 test-pull-bundle.t
 test-pull-http.t
 test-pull-permission.t
 test-pull-pull-corruption.t
 test-pull-r.t
 test-pull-update.t
 test-pull.t
 test-purge.t
 test-push-cgi.t
 test-push-checkheads-partial-C1.t
 test-push-checkheads-partial-C2.t
 test-push-checkheads-partial-C3.t
 test-push-checkheads-partial-C4.t
 test-push-checkheads-pruned-B1.t
 test-push-checkheads-pruned-B2.t
 test-push-checkheads-pruned-B3.t
 test-push-checkheads-pruned-B4.t
 test-push-checkheads-pruned-B5.t
 test-push-checkheads-pruned-B6.t
 test-push-checkheads-pruned-B7.t
 test-push-checkheads-pruned-B8.t
 test-push-checkheads-superceed-A1.t
 test-push-checkheads-superceed-A2.t
 test-push-checkheads-superceed-A3.t
 test-push-checkheads-superceed-A4.t
 test-push-checkheads-superceed-A5.t
 test-push-checkheads-superceed-A6.t
 test-push-checkheads-superceed-A7.t
 test-push-checkheads-superceed-A8.t
 test-push-checkheads-unpushed-D1.t
 test-push-checkheads-unpushed-D2.t
 test-push-checkheads-unpushed-D3.t
 test-push-checkheads-unpushed-D4.t
 test-push-checkheads-unpushed-D5.t
 test-push-checkheads-unpushed-D6.t
 test-push-checkheads-unpushed-D7.t
 test-push-http.t
 test-push-race.t
 test-push-warn.t
 test-push.t
 test-pushvars.t
 test-qrecord.t
 test-rebase-abort.t
 test-rebase-backup.t
 test-rebase-base-flag.t
 test-rebase-bookmarks.t
 test-rebase-brute-force.t
 test-rebase-cache.t
 test-rebase-check-restore.t
 test-rebase-collapse.t
 test-rebase-conflicts.t
 test-rebase-dest.t
 test-rebase-detach.t
 test-rebase-emptycommit.t
 test-rebase-inmemory.t
 test-rebase-interruptions.t
 test-rebase-issue-noparam-single-rev.t
 test-rebase-legacy.t
 test-rebase-mq-skip.t
 test-rebase-mq.t
 test-rebase-named-branches.t
 test-rebase-newancestor.t
 test-rebase-obsolete.t
 test-rebase-parameters.t
 test-rebase-partial.t
 test-rebase-pull.t
 test-rebase-rename.t
 test-rebase-scenario-global.t
 test-rebase-templates.t
 test-rebase-transaction.t
 test-rebuildstate.t
 test-record.t
 test-releasenotes-formatting.t
 test-releasenotes-merging.t
 test-releasenotes-parsing.t
 test-relink.t
 test-remotefilelog-bad-configs.t
 test-remotefilelog-bgprefetch.t
 test-remotefilelog-blame.t
 test-remotefilelog-bundle2.t
 test-remotefilelog-bundles.t
 test-remotefilelog-cacheprocess.t
 test-remotefilelog-clone-tree.t
 test-remotefilelog-clone.t
 test-remotefilelog-datapack.py
 test-remotefilelog-gcrepack.t
 test-remotefilelog-histpack.py
 test-remotefilelog-http.t
 test-remotefilelog-keepset.t
 test-remotefilelog-local.t
 test-remotefilelog-log.t
 test-remotefilelog-partial-shallow.t
 test-remotefilelog-permissions.t
 test-remotefilelog-permisssions.t
 test-remotefilelog-prefetch.t
 test-remotefilelog-pull-noshallow.t
 test-remotefilelog-share.t
 test-remotefilelog-sparse.t
 test-remotefilelog-tags.t
 test-remotefilelog-wireproto.t
 test-remove.t
 test-removeemptydirs.t
 test-rename-after-merge.t
 test-rename-dir-merge.t
 test-rename-merge1.t
 test-rename-merge2.t
 test-rename.t
 test-repair-strip.t
 test-repo-compengines.t
 test-requires.t
 test-resolve.t
 test-revert-flags.t
 test-revert-interactive.t
 test-revert-unknown.t
 test-revert.t
 test-revisions.t
 test-revlog-ancestry.py
 test-revlog-group-emptyiter.t
 test-revlog-mmapindex.t
 test-revlog-packentry.t
 test-revlog-raw.py
 test-revlog-v2.t
 test-revlog.t
 test-revset-dirstate-parents.t
 test-revset-legacy-lookup.t
 test-revset-outgoing.t
 test-revset2.t
 test-rollback.t
 test-run-tests.py
 test-run-tests.t
 test-rust-ancestor.py
 test-schemes.t
 test-serve.t
 test-setdiscovery.t
 test-share.t
 test-shelve.t
 test-shelve2.t
 test-show-stack.t
 test-show-work.t
 test-show.t
 test-simple-update.t
 test-simplekeyvaluefile.py
 test-simplemerge.py
 test-single-head.t
 test-sparse-clear.t
 test-sparse-clone.t
 test-sparse-import.t
 test-sparse-merges.t
 test-sparse-profiles.t
 test-sparse-requirement.t
 test-sparse-verbose-json.t
 test-sparse.t
 test-split.t
 test-ssh-bundle1.t
 test-ssh-clone-r.t
 test-ssh-proto-unbundle.t
 test-ssh-proto.t
 test-ssh-repoerror.t
 test-ssh.t
 test-sshserver.py
 test-stack.t
 test-static-http.t
 test-status-color.t
 test-status-inprocess.py
 test-status-rev.t
 test-status-terse.t
 test-status.t
 test-storage.py
 test-stream-bundle-v2.t
 test-strict.t
 test-strip-cross.t
 test-strip.t
 test-subrepo-deep-nested-change.t
 test-subrepo-missing.t
 test-subrepo-paths.t
 test-subrepo-recursion.t
 test-subrepo-relative-path.t
 test-subrepo.t
 test-symlink-os-yes-fs-no.py
 test-symlink-placeholder.t
 test-symlinks.t
 test-tag.t
 test-tags.t
 test-template-basic.t
 test-template-functions.t
 test-template-keywords.t
 test-template-map.t
 test-tools.t
 test-transplant.t
 test-treediscovery-legacy.t
 test-treediscovery.t
 test-treemanifest.t
 test-ui-color.py
 test-ui-config.py
 test-ui-verbosity.py
 test-unamend.t
 test-unbundlehash.t
 test-uncommit.t
 test-unified-test.t
 test-unionrepo.t
 test-unrelated-pull.t
 test-up-local-change.t
 test-update-atomic.t
 test-update-branches.t
 test-update-dest.t
 test-update-issue1456.t
 test-update-names.t
 test-update-reverse.t
 test-upgrade-repo.t
 test-url-download.t
 test-url-rev.t
 test-url.py
 test-username-newline.t
 test-util.py
 test-verify.t
 test-walk.t
 test-walkrepo.py
 test-websub.t
 test-win32text.t
 test-wireproto-caching.t
 test-wireproto-clientreactor.py
 test-wireproto-command-branchmap.t
 test-wireproto-command-capabilities.t
 test-wireproto-command-changesetdata.t
 test-wireproto-command-filedata.t
 test-wireproto-command-filesdata.t
 test-wireproto-command-heads.t
 test-wireproto-command-known.t
 test-wireproto-command-listkeys.t
 test-wireproto-command-lookup.t
 test-wireproto-command-manifestdata.t
 test-wireproto-command-pushkey.t
 test-wireproto-command-rawstorefiledata.t
 test-wireproto-content-redirects.t
 test-wireproto-exchangev2.t
 test-wireproto-framing.py
 test-wireproto-serverreactor.py
 test-wireproto.py
 test-wireproto.t
 test-wsgirequest.py
 test-xdg.t

hgext/convert/git.py

@@ -1,478 +1,480 b''
 # git.py - git support for the convert extension
 #
 #  Copyright 2005-2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 from __future__ import absolute_import
 
 import os
 
 from mercurial.i18n import _
 from mercurial import (
     config,
     error,
     node as nodemod,
+    pycompat,
 )
 
 from . import (
     common,
 )
 
 class submodule(object):
     def __init__(self, path, node, url):
         self.path = path
         self.node = node
         self.url = url
 
     def hgsub(self):
         return "%s = [git]%s" % (self.path, self.url)
 
     def hgsubstate(self):
         return "%s %s" % (self.node, self.path)
 
 # Keys in extra fields that should not be copied if the user requests.
 bannedextrakeys = {
     # Git commit object built-ins.
     'tree',
     'parent',
     'author',
     'committer',
     # Mercurial built-ins.
     'branch',
     'close',
 }
 
 class convert_git(common.converter_source, common.commandline):
     # Windows does not support GIT_DIR= construct while other systems
     # cannot remove environment variable. Just assume none have
     # both issues.
 
     def _gitcmd(self, cmd, *args, **kwargs):
         return cmd('--git-dir=%s' % self.path, *args, **kwargs)
 
     def gitrun0(self, *args, **kwargs):
         return self._gitcmd(self.run0, *args, **kwargs)
 
     def gitrun(self, *args, **kwargs):
         return self._gitcmd(self.run, *args, **kwargs)
 
     def gitrunlines0(self, *args, **kwargs):
         return self._gitcmd(self.runlines0, *args, **kwargs)
 
     def gitrunlines(self, *args, **kwargs):
         return self._gitcmd(self.runlines, *args, **kwargs)
 
     def gitpipe(self, *args, **kwargs):
         return self._gitcmd(self._run3, *args, **kwargs)
 
     def __init__(self, ui, repotype, path, revs=None):
         super(convert_git, self).__init__(ui, repotype, path, revs=revs)
         common.commandline.__init__(self, ui, 'git')
 
         # Pass an absolute path to git to prevent from ever being interpreted
         # as a URL
         path = os.path.abspath(path)
 
         if os.path.isdir(path + "/.git"):
             path += "/.git"
         if not os.path.exists(path + "/objects"):
             raise common.NoRepo(_("%s does not look like a Git repository") %
                                 path)
 
         # The default value (50) is based on the default for 'git diff'.
         similarity = ui.configint('convert', 'git.similarity')
         if similarity < 0 or similarity > 100:
             raise error.Abort(_('similarity must be between 0 and 100'))
         if similarity > 0:
             self.simopt = ['-C%d%%' % similarity]
             findcopiesharder = ui.configbool('convert', 'git.findcopiesharder')
             if findcopiesharder:
                 self.simopt.append('--find-copies-harder')
 
             renamelimit = ui.configint('convert', 'git.renamelimit')
             self.simopt.append('-l%d' % renamelimit)
         else:
             self.simopt = []
 
         common.checktool('git', 'git')
 
         self.path = path
         self.submodules = []
 
         self.catfilepipe = self.gitpipe('cat-file', '--batch')
 
         self.copyextrakeys = self.ui.configlist('convert', 'git.extrakeys')
         banned = set(self.copyextrakeys) & bannedextrakeys
         if banned:
             raise error.Abort(_('copying of extra key is forbidden: %s') %
                               _(', ').join(sorted(banned)))
 
         committeractions = self.ui.configlist('convert', 'git.committeractions')
 
         messagedifferent = None
         messagealways = None
         for a in committeractions:
             if a.startswith(('messagedifferent', 'messagealways')):
                 k = a
                 v = None
                 if '=' in a:
                     k, v = a.split('=', 1)
 
                 if k == 'messagedifferent':
                     messagedifferent = v or 'committer:'
                 elif k == 'messagealways':
                     messagealways = v or 'committer:'
 
         if messagedifferent and messagealways:
             raise error.Abort(_('committeractions cannot define both '
                                 'messagedifferent and messagealways'))
 
         dropcommitter = 'dropcommitter' in committeractions
         replaceauthor = 'replaceauthor' in committeractions
 
         if dropcommitter and replaceauthor:
             raise error.Abort(_('committeractions cannot define both '
                                 'dropcommitter and replaceauthor'))
 
         if dropcommitter and messagealways:
             raise error.Abort(_('committeractions cannot define both '
                                 'dropcommitter and messagealways'))
 
         if not messagedifferent and not messagealways:
             messagedifferent = 'committer:'
 
         self.committeractions = {
             'dropcommitter': dropcommitter,
             'replaceauthor': replaceauthor,
             'messagedifferent': messagedifferent,
             'messagealways': messagealways,
         }
 
     def after(self):
         for f in self.catfilepipe:
             f.close()
 
     def getheads(self):
         if not self.revs:
             output, status = self.gitrun('rev-parse', '--branches', '--remotes')
             heads = output.splitlines()
             if status:
                 raise error.Abort(_('cannot retrieve git heads'))
         else:
             heads = []
             for rev in self.revs:
                 rawhead, ret = self.gitrun('rev-parse', '--verify', rev)
                 heads.append(rawhead[:-1])
                 if ret:
                     raise error.Abort(_('cannot retrieve git head "%s"') % rev)
         return heads
 
     def catfile(self, rev, ftype):
         if rev == nodemod.nullhex:
             raise IOError
         self.catfilepipe[0].write(rev+'\n')
         self.catfilepipe[0].flush()
         info = self.catfilepipe[1].readline().split()
         if info[1] != ftype:
-            raise error.Abort(_('cannot read %r object at %s') % (ftype, rev))
+            raise error.Abort(_('cannot read %r object at %s') % (
+                pycompat.bytestr(ftype), rev))
         size = int(info[2])
         data = self.catfilepipe[1].read(size)
         if len(data) < size:
             raise error.Abort(_('cannot read %r object at %s: unexpected size')
                               % (ftype, rev))
         # read the trailing newline
         self.catfilepipe[1].read(1)
         return data
 
     def getfile(self, name, rev):
         if rev == nodemod.nullhex:
             return None, None
         if name == '.hgsub':
             data = '\n'.join([m.hgsub() for m in self.submoditer()])
             mode = ''
         elif name == '.hgsubstate':
             data = '\n'.join([m.hgsubstate() for m in self.submoditer()])
             mode = ''
         else:
             data = self.catfile(rev, "blob")
             mode = self.modecache[(name, rev)]
         return data, mode
 
     def submoditer(self):
         null = nodemod.nullhex
         for m in sorted(self.submodules, key=lambda p: p.path):
             if m.node != null:
                 yield m
 
     def parsegitmodules(self, content):
         """Parse the formatted .gitmodules file, example file format:
         [submodule "sub"]\n
         \tpath = sub\n
         \turl = git://giturl\n
         """
         self.submodules = []
         c = config.config()
         # Each item in .gitmodules starts with whitespace that cant be parsed
         c.parse('.gitmodules', '\n'.join(line.strip() for line in
                                content.split('\n')))
         for sec in c.sections():
             s = c[sec]
             if 'url' in s and 'path' in s:
                 self.submodules.append(submodule(s['path'], '', s['url']))
 
     def retrievegitmodules(self, version):
         modules, ret = self.gitrun('show', '%s:%s' % (version, '.gitmodules'))
         if ret:
             # This can happen if a file is in the repo that has permissions
             # 160000, but there is no .gitmodules file.
             self.ui.warn(_("warning: cannot read submodules config file in "
                            "%s\n") % version)
             return
 
         try:
             self.parsegitmodules(modules)
         except error.ParseError:
             self.ui.warn(_("warning: unable to parse .gitmodules in %s\n")
                          % version)
             return
 
         for m in self.submodules:
             node, ret = self.gitrun('rev-parse', '%s:%s' % (version, m.path))
             if ret:
                 continue
             m.node = node.strip()
 
     def getchanges(self, version, full):
         if full:
             raise error.Abort(_("convert from git does not support --full"))
         self.modecache = {}
         cmd = ['diff-tree','-z', '--root', '-m', '-r'] + self.simopt + [version]
         output, status = self.gitrun(*cmd)
         if status:
             raise error.Abort(_('cannot read changes in %s') % version)
         changes = []
         copies = {}
         seen = set()
         entry = None
         subexists = [False]
         subdeleted = [False]
         difftree = output.split('\x00')
         lcount = len(difftree)
         i = 0
 
         skipsubmodules = self.ui.configbool('convert', 'git.skipsubmodules')
         def add(entry, f, isdest):
             seen.add(f)
             h = entry[3]
             p = (entry[1] == "100755")
             s = (entry[1] == "120000")
             renamesource = (not isdest and entry[4][0] == 'R')
 
             if f == '.gitmodules':
                 if skipsubmodules:
                     return
 
                 subexists[0] = True
                 if entry[4] == 'D' or renamesource:
                     subdeleted[0] = True
                     changes.append(('.hgsub', nodemod.nullhex))
                 else:
                     changes.append(('.hgsub', ''))
             elif entry[1] == '160000' or entry[0] == ':160000':
                 if not skipsubmodules:
                     subexists[0] = True
             else:
                 if renamesource:
                     h = nodemod.nullhex
                 self.modecache[(f, h)] = (p and "x") or (s and "l") or ""
                 changes.append((f, h))
 
         while i < lcount:
             l = difftree[i]
             i += 1
             if not entry:
                 if not l.startswith(':'):
                     continue
-                entry = l.split()
+                entry = tuple(pycompat.bytestr(p) for p in l.split())
                 continue
             f = l
             if entry[4][0] == 'C':
                 copysrc = f
                 copydest = difftree[i]
                 i += 1
                 f = copydest
                 copies[copydest] = copysrc
             if f not in seen:
                 add(entry, f, False)
             # A file can be copied multiple times, or modified and copied
             # simultaneously. So f can be repeated even if fdest isn't.
             if entry[4][0] == 'R':
                 # rename: next line is the destination
                 fdest = difftree[i]
                 i += 1
                 if fdest not in seen:
                     add(entry, fdest, True)
                     # .gitmodules isn't imported at all, so it being copied to
                     # and fro doesn't really make sense
                     if f != '.gitmodules' and fdest != '.gitmodules':
                         copies[fdest] = f
             entry = None
 
         if subexists[0]:
             if subdeleted[0]:
                 changes.append(('.hgsubstate', nodemod.nullhex))
             else:
                 self.retrievegitmodules(version)
                 changes.append(('.hgsubstate', ''))
         return (changes, copies, set())
 
     def getcommit(self, version):
         c = self.catfile(version, "commit") # read the commit hash
         end = c.find("\n\n")
         message = c[end + 2:]
         message = self.recode(message)
         l = c[:end].splitlines()
         parents = []
         author = committer = None
         extra = {}
         for e in l[1:]:
             n, v = e.split(" ", 1)
             if n == "author":
                 p = v.split()
                 tm, tz = p[-2:]
                 author = " ".join(p[:-2])
                 if author[0] == "<":
                     author = author[1:-1]
                 author = self.recode(author)
             if n == "committer":
                 p = v.split()
                 tm, tz = p[-2:]
                 committer = " ".join(p[:-2])
                 if committer[0] == "<":
                     committer = committer[1:-1]
                 committer = self.recode(committer)
             if n == "parent":
                 parents.append(v)
             if n in self.copyextrakeys:
                 extra[n] = v
 
         if self.committeractions['dropcommitter']:
             committer = None
         elif self.committeractions['replaceauthor']:
             author = committer
 
         if committer:
             messagealways = self.committeractions['messagealways']
             messagedifferent = self.committeractions['messagedifferent']
             if messagealways:
                 message += '\n%s %s\n' % (messagealways, committer)
             elif messagedifferent and author != committer:
                 message += '\n%s %s\n' % (messagedifferent, committer)
 
         tzs, tzh, tzm = tz[-5:-4] + "1", tz[-4:-2], tz[-2:]
         tz = -int(tzs) * (int(tzh) * 3600 + int(tzm))
         date = tm + " " + (b"%d" % tz)
         saverev = self.ui.configbool('convert', 'git.saverev')
 
         c = common.commit(parents=parents, date=date, author=author,
                           desc=message,
                           rev=version,
                           extra=extra,
                           saverev=saverev)
         return c
 
     def numcommits(self):
         output, ret = self.gitrunlines('rev-list', '--all')
         if ret:
             raise error.Abort(_('cannot retrieve number of commits in %s') \
                               % self.path)
         return len(output)
 
     def gettags(self):
         tags = {}
         alltags = {}
         output, status = self.gitrunlines('ls-remote', '--tags', self.path)
 
         if status:
             raise error.Abort(_('cannot read tags from %s') % self.path)
         prefix = 'refs/tags/'
 
         # Build complete list of tags, both annotated and bare ones
         for line in output:
             line = line.strip()
             if line.startswith("error:") or line.startswith("fatal:"):
                 raise error.Abort(_('cannot read tags from %s') % self.path)
             node, tag = line.split(None, 1)
             if not tag.startswith(prefix):
                 continue
             alltags[tag[len(prefix):]] = node
 
         # Filter out tag objects for annotated tag refs
         for tag in alltags:
             if tag.endswith('^{}'):
                 tags[tag[:-3]] = alltags[tag]
             else:
                 if tag + '^{}' in alltags:
                     continue
                 else:
                     tags[tag] = alltags[tag]
 
         return tags
 
     def getchangedfiles(self, version, i):
         changes = []
         if i is None:
             output, status = self.gitrunlines('diff-tree', '--root', '-m',
                                               '-r', version)
             if status:
                 raise error.Abort(_('cannot read changes in %s') % version)
             for l in output:
                 if "\t" not in l:
                     continue
                 m, f = l[:-1].split("\t")
                 changes.append(f)
         else:
             output, status = self.gitrunlines('diff-tree', '--name-only',
                                               '--root', '-r', version,
                                               '%s^%d' % (version, i + 1), '--')
             if status:
                 raise error.Abort(_('cannot read changes in %s') % version)
             changes = [f.rstrip('\n') for f in output]
 
         return changes
 
     def getbookmarks(self):
         bookmarks = {}
 
         # Handle local and remote branches
         remoteprefix = self.ui.config('convert', 'git.remoteprefix')
         reftypes = [
             # (git prefix, hg prefix)
             ('refs/remotes/origin/', remoteprefix + '/'),
             ('refs/heads/', '')
         ]
 
         exclude = {
             'refs/remotes/origin/HEAD',
         }
 
         try:
             output, status = self.gitrunlines('show-ref')
             for line in output:
                 line = line.strip()
                 rev, name = line.split(None, 1)
                 # Process each type of branch
                 for gitprefix, hgprefix in reftypes:
                     if not name.startswith(gitprefix) or name in exclude:
                         continue
                     name = '%s%s' % (hgprefix, name[len(gitprefix):])
                     bookmarks[name] = rev
         except Exception:
             pass
 
         return bookmarks
 
     def checkrevformat(self, revstr, mapname='splicemap'):
         """ git revision string is a 40 byte hex """
         self.checkhexformat(revstr, mapname)