convert: remove pycompat.iteritems()

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

hgext/convert/cvs.py

@@ -1,331 +1,330 b''
 # cvs.py: CVS conversion code inspired by hg-cvs-import and git-cvsimport
 #
 #  Copyright 2005-2009 Olivia 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.
 
 import errno
 import os
 import re
 import socket
 
 from mercurial.i18n import _
 from mercurial.pycompat import (
     getattr,
     open,
 )
 from mercurial import (
     encoding,
     error,
-    pycompat,
     util,
 )
 from mercurial.utils import (
     dateutil,
     procutil,
 )
 
 from . import (
     common,
     cvsps,
 )
 
 stringio = util.stringio
 checktool = common.checktool
 commit = common.commit
 converter_source = common.converter_source
 makedatetimestamp = common.makedatetimestamp
 NoRepo = common.NoRepo
 
 
 class convert_cvs(converter_source):
     def __init__(self, ui, repotype, path, revs=None):
         super(convert_cvs, self).__init__(ui, repotype, path, revs=revs)
 
         cvs = os.path.join(path, b"CVS")
         if not os.path.exists(cvs):
             raise NoRepo(_(b"%s does not look like a CVS checkout") % path)
 
         checktool(b'cvs')
 
         self.changeset = None
         self.files = {}
         self.tags = {}
         self.lastbranch = {}
         self.socket = None
         self.cvsroot = open(os.path.join(cvs, b"Root"), b'rb').read()[:-1]
         self.cvsrepo = open(os.path.join(cvs, b"Repository"), b'rb').read()[:-1]
         self.encoding = encoding.encoding
 
         self._connect()
 
     def _parse(self):
         if self.changeset is not None:
             return
         self.changeset = {}
 
         maxrev = 0
         if self.revs:
             if len(self.revs) > 1:
                 raise error.Abort(
                     _(
                         b'cvs source does not support specifying '
                         b'multiple revs'
                     )
                 )
             # TODO: handle tags
             try:
                 # patchset number?
                 maxrev = int(self.revs[0])
             except ValueError:
                 raise error.Abort(
                     _(b'revision %s is not a patchset number') % self.revs[0]
                 )
 
         d = encoding.getcwd()
         try:
             os.chdir(self.path)
 
             cache = b'update'
             if not self.ui.configbool(b'convert', b'cvsps.cache'):
                 cache = None
             db = cvsps.createlog(self.ui, cache=cache)
             db = cvsps.createchangeset(
                 self.ui,
                 db,
                 fuzz=int(self.ui.config(b'convert', b'cvsps.fuzz')),
                 mergeto=self.ui.config(b'convert', b'cvsps.mergeto'),
                 mergefrom=self.ui.config(b'convert', b'cvsps.mergefrom'),
             )
 
             for cs in db:
                 if maxrev and cs.id > maxrev:
                     break
                 id = b"%d" % cs.id
                 cs.author = self.recode(cs.author)
                 self.lastbranch[cs.branch] = id
                 cs.comment = self.recode(cs.comment)
                 if self.ui.configbool(b'convert', b'localtimezone'):
                     cs.date = makedatetimestamp(cs.date[0])
                 date = dateutil.datestr(cs.date, b'%Y-%m-%d %H:%M:%S %1%2')
                 self.tags.update(dict.fromkeys(cs.tags, id))
 
                 files = {}
                 for f in cs.entries:
                     files[f.file] = b"%s%s" % (
                         b'.'.join([(b"%d" % x) for x in f.revision]),
                         [b'', b'(DEAD)'][f.dead],
                     )
 
                 # add current commit to set
                 c = commit(
                     author=cs.author,
                     date=date,
                     parents=[(b"%d" % p.id) for p in cs.parents],
                     desc=cs.comment,
                     branch=cs.branch or b'',
                 )
                 self.changeset[id] = c
                 self.files[id] = files
 
             self.heads = self.lastbranch.values()
         finally:
             os.chdir(d)
 
     def _connect(self):
         root = self.cvsroot
         conntype = None
         user, host = None, None
         cmd = [b'cvs', b'server']
 
         self.ui.status(_(b"connecting to %s\n") % root)
 
         if root.startswith(b":pserver:"):
             root = root[9:]
             m = re.match(r'(?:(.*?)(?::(.*?))?@)?([^:/]*)(?::(\d*))?(.*)', root)
             if m:
                 conntype = b"pserver"
                 user, passw, serv, port, root = m.groups()
                 if not user:
                     user = b"anonymous"
                 if not port:
                     port = 2401
                 else:
                     port = int(port)
                 format0 = b":pserver:%s@%s:%s" % (user, serv, root)
                 format1 = b":pserver:%s@%s:%d%s" % (user, serv, port, root)
 
                 if not passw:
                     passw = b"A"
                     cvspass = os.path.expanduser(b"~/.cvspass")
                     try:
                         pf = open(cvspass, b'rb')
                         for line in pf.read().splitlines():
                             part1, part2 = line.split(b' ', 1)
                             # /1 :pserver:[e-mail]:2401/cvsroot/foo
                             # Ah<Z
                             if part1 == b'/1':
                                 part1, part2 = part2.split(b' ', 1)
                                 format = format1
                             # :pserver:[e-mail]:/cvsroot/foo Ah<Z
                             else:
                                 format = format0
                             if part1 == format:
                                 passw = part2
                                 break
                         pf.close()
                     except IOError as inst:
                         if inst.errno != errno.ENOENT:
                             if not getattr(inst, 'filename', None):
                                 inst.filename = cvspass
                             raise
 
                 sck = socket.socket()
                 sck.connect((serv, port))
                 sck.send(
                     b"\n".join(
                         [
                             b"BEGIN AUTH REQUEST",
                             root,
                             user,
                             passw,
                             b"END AUTH REQUEST",
                             b"",
                         ]
                     )
                 )
                 if sck.recv(128) != b"I LOVE YOU\n":
                     raise error.Abort(_(b"CVS pserver authentication failed"))
 
                 self.writep = self.readp = sck.makefile(b'r+')
 
         if not conntype and root.startswith(b":local:"):
             conntype = b"local"
             root = root[7:]
 
         if not conntype:
             # :ext:user@host/home/user/path/to/cvsroot
             if root.startswith(b":ext:"):
                 root = root[5:]
             m = re.match(br'(?:([^@:/]+)@)?([^:/]+):?(.*)', root)
             # Do not take Windows path "c:\foo\bar" for a connection strings
             if os.path.isdir(root) or not m:
                 conntype = b"local"
             else:
                 conntype = b"rsh"
                 user, host, root = m.group(1), m.group(2), m.group(3)
 
         if conntype != b"pserver":
             if conntype == b"rsh":
                 rsh = encoding.environ.get(b"CVS_RSH") or b"ssh"
                 if user:
                     cmd = [rsh, b'-l', user, host] + cmd
                 else:
                     cmd = [rsh, host] + cmd
 
             # popen2 does not support argument lists under Windows
             cmd = b' '.join(procutil.shellquote(arg) for arg in cmd)
             self.writep, self.readp = procutil.popen2(cmd)
 
         self.realroot = root
 
         self.writep.write(b"Root %s\n" % root)
         self.writep.write(
             b"Valid-responses ok error Valid-requests Mode"
             b" M Mbinary E Checked-in Created Updated"
             b" Merged Removed\n"
         )
         self.writep.write(b"valid-requests\n")
         self.writep.flush()
         r = self.readp.readline()
         if not r.startswith(b"Valid-requests"):
             raise error.Abort(
                 _(
                     b'unexpected response from CVS server '
                     b'(expected "Valid-requests", but got %r)'
                 )
                 % r
             )
         if b"UseUnchanged" in r:
             self.writep.write(b"UseUnchanged\n")
             self.writep.flush()
             self.readp.readline()
 
     def getheads(self):
         self._parse()
         return self.heads
 
     def getfile(self, name, rev):
         def chunkedread(fp, count):
             # file-objects returned by socket.makefile() do not handle
             # large read() requests very well.
             chunksize = 65536
             output = stringio()
             while count > 0:
                 data = fp.read(min(count, chunksize))
                 if not data:
                     raise error.Abort(
                         _(b"%d bytes missing from remote file") % count
                     )
                 count -= len(data)
                 output.write(data)
             return output.getvalue()
 
         self._parse()
         if rev.endswith(b"(DEAD)"):
             return None, None
 
         args = (b"-N -P -kk -r %s --" % rev).split()
         args.append(self.cvsrepo + b'/' + name)
         for x in args:
             self.writep.write(b"Argument %s\n" % x)
         self.writep.write(b"Directory .\n%s\nco\n" % self.realroot)
         self.writep.flush()
 
         data = b""
         mode = None
         while True:
             line = self.readp.readline()
             if line.startswith(b"Created ") or line.startswith(b"Updated "):
                 self.readp.readline()  # path
                 self.readp.readline()  # entries
                 mode = self.readp.readline()[:-1]
                 count = int(self.readp.readline()[:-1])
                 data = chunkedread(self.readp, count)
             elif line.startswith(b" "):
                 data += line[1:]
             elif line.startswith(b"M "):
                 pass
             elif line.startswith(b"Mbinary "):
                 count = int(self.readp.readline()[:-1])
                 data = chunkedread(self.readp, count)
             else:
                 if line == b"ok\n":
                     if mode is None:
                         raise error.Abort(_(b'malformed response from CVS'))
                     return (data, b"x" in mode and b"x" or b"")
                 elif line.startswith(b"E "):
                     self.ui.warn(_(b"cvs server: %s\n") % line[2:])
                 elif line.startswith(b"Remove"):
                     self.readp.readline()
                 else:
                     raise error.Abort(_(b"unknown CVS response: %s") % line)
 
     def getchanges(self, rev, full):
         if full:
             raise error.Abort(_(b"convert from cvs does not support --full"))
         self._parse()
-        return sorted(pycompat.iteritems(self.files[rev])), {}, set()
+        return sorted(self.files[rev].items()), {}, set()
 
     def getcommit(self, rev):
         self._parse()
         return self.changeset[rev]
 
     def gettags(self):
         self._parse()
         return self.tags
 
     def getchangedfiles(self, rev, i):
         self._parse()
         return sorted(self.files[rev])

hgext/convert/hg.py

@@ -1,732 +1,731 b''
 # hg.py - hg backend for convert extension
 #
 #  Copyright 2005-2009 Olivia 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.
 
 # Notes for hg->hg conversion:
 #
 # * Old versions of Mercurial didn't trim the whitespace from the ends
 #   of commit messages, but new versions do.  Changesets created by
 #   those older versions, then converted, may thus have different
 #   hashes for changesets that are otherwise identical.
 #
 # * Using "--config convert.hg.saverev=true" will make the source
 #   identifier to be stored in the converted revision. This will cause
 #   the converted revision to have a different identity than the
 #   source.
 
 import os
 import re
 import time
 
 from mercurial.i18n import _
 from mercurial.pycompat import open
 from mercurial.node import (
     bin,
     hex,
     sha1nodeconstants,
 )
 from mercurial import (
     bookmarks,
     context,
     error,
     exchange,
     hg,
     lock as lockmod,
     logcmdutil,
     merge as mergemod,
     mergestate,
     phases,
-    pycompat,
     util,
 )
 from mercurial.utils import dateutil
 
 stringio = util.stringio
 
 from . import common
 
 mapfile = common.mapfile
 NoRepo = common.NoRepo
 
 sha1re = re.compile(br'\b[0-9a-f]{12,40}\b')
 
 
 class mercurial_sink(common.converter_sink):
     def __init__(self, ui, repotype, path):
         common.converter_sink.__init__(self, ui, repotype, path)
         self.branchnames = ui.configbool(b'convert', b'hg.usebranchnames')
         self.clonebranches = ui.configbool(b'convert', b'hg.clonebranches')
         self.tagsbranch = ui.config(b'convert', b'hg.tagsbranch')
         self.lastbranch = None
         if os.path.isdir(path) and len(os.listdir(path)) > 0:
             try:
                 self.repo = hg.repository(self.ui, path)
                 if not self.repo.local():
                     raise NoRepo(
                         _(b'%s is not a local Mercurial repository') % path
                     )
             except error.RepoError as err:
                 ui.traceback()
                 raise NoRepo(err.args[0])
         else:
             try:
                 ui.status(_(b'initializing destination %s repository\n') % path)
                 self.repo = hg.repository(self.ui, path, create=True)
                 if not self.repo.local():
                     raise NoRepo(
                         _(b'%s is not a local Mercurial repository') % path
                     )
                 self.created.append(path)
             except error.RepoError:
                 ui.traceback()
                 raise NoRepo(
                     _(b"could not create hg repository %s as sink") % path
                 )
         self.lock = None
         self.wlock = None
         self.filemapmode = False
         self.subrevmaps = {}
 
     def before(self):
         self.ui.debug(b'run hg sink pre-conversion action\n')
         self.wlock = self.repo.wlock()
         self.lock = self.repo.lock()
 
     def after(self):
         self.ui.debug(b'run hg sink post-conversion action\n')
         if self.lock:
             self.lock.release()
         if self.wlock:
             self.wlock.release()
 
     def revmapfile(self):
         return self.repo.vfs.join(b"shamap")
 
     def authorfile(self):
         return self.repo.vfs.join(b"authormap")
 
     def setbranch(self, branch, pbranches):
         if not self.clonebranches:
             return
 
         setbranch = branch != self.lastbranch
         self.lastbranch = branch
         if not branch:
             branch = b'default'
         pbranches = [(b[0], b[1] and b[1] or b'default') for b in pbranches]
 
         branchpath = os.path.join(self.path, branch)
         if setbranch:
             self.after()
             try:
                 self.repo = hg.repository(self.ui, branchpath)
             except Exception:
                 self.repo = hg.repository(self.ui, branchpath, create=True)
             self.before()
 
         # pbranches may bring revisions from other branches (merge parents)
         # Make sure we have them, or pull them.
         missings = {}
         for b in pbranches:
             try:
                 self.repo.lookup(b[0])
             except Exception:
                 missings.setdefault(b[1], []).append(b[0])
 
         if missings:
             self.after()
             for pbranch, heads in sorted(missings.items()):
                 pbranchpath = os.path.join(self.path, pbranch)
                 prepo = hg.peer(self.ui, {}, pbranchpath)
                 self.ui.note(
                     _(b'pulling from %s into %s\n') % (pbranch, branch)
                 )
                 exchange.pull(
                     self.repo, prepo, heads=[prepo.lookup(h) for h in heads]
                 )
             self.before()
 
     def _rewritetags(self, source, revmap, data):
         fp = stringio()
         for line in data.splitlines():
             s = line.split(b' ', 1)
             if len(s) != 2:
                 self.ui.warn(_(b'invalid tag entry: "%s"\n') % line)
                 fp.write(b'%s\n' % line)  # Bogus, but keep for hash stability
                 continue
             revid = revmap.get(source.lookuprev(s[0]))
             if not revid:
                 if s[0] == sha1nodeconstants.nullhex:
                     revid = s[0]
                 else:
                     # missing, but keep for hash stability
                     self.ui.warn(_(b'missing tag entry: "%s"\n') % line)
                     fp.write(b'%s\n' % line)
                     continue
             fp.write(b'%s %s\n' % (revid, s[1]))
         return fp.getvalue()
 
     def _rewritesubstate(self, source, data):
         fp = stringio()
         for line in data.splitlines():
             s = line.split(b' ', 1)
             if len(s) != 2:
                 continue
 
             revid = s[0]
             subpath = s[1]
             if revid != sha1nodeconstants.nullhex:
                 revmap = self.subrevmaps.get(subpath)
                 if revmap is None:
                     revmap = mapfile(
                         self.ui, self.repo.wjoin(subpath, b'.hg/shamap')
                     )
                     self.subrevmaps[subpath] = revmap
 
                     # It is reasonable that one or more of the subrepos don't
                     # need to be converted, in which case they can be cloned
                     # into place instead of converted.  Therefore, only warn
                     # once.
                     msg = _(b'no ".hgsubstate" updates will be made for "%s"\n')
                     if len(revmap) == 0:
                         sub = self.repo.wvfs.reljoin(subpath, b'.hg')
 
                         if self.repo.wvfs.exists(sub):
                             self.ui.warn(msg % subpath)
 
                 newid = revmap.get(revid)
                 if not newid:
                     if len(revmap) > 0:
                         self.ui.warn(
                             _(b"%s is missing from %s/.hg/shamap\n")
                             % (revid, subpath)
                         )
                 else:
                     revid = newid
 
             fp.write(b'%s %s\n' % (revid, subpath))
 
         return fp.getvalue()
 
     def _calculatemergedfiles(self, source, p1ctx, p2ctx):
         """Calculates the files from p2 that we need to pull in when merging p1
         and p2, given that the merge is coming from the given source.
 
         This prevents us from losing files that only exist in the target p2 and
         that don't come from the source repo (like if you're merging multiple
         repositories together).
         """
         anc = [p1ctx.ancestor(p2ctx)]
         # Calculate what files are coming from p2
         # TODO: mresult.commitinfo might be able to get that info
         mresult = mergemod.calculateupdates(
             self.repo,
             p1ctx,
             p2ctx,
             anc,
             branchmerge=True,
             force=True,
             acceptremote=False,
             followcopies=False,
         )
 
         for file, (action, info, msg) in mresult.filemap():
             if source.targetfilebelongstosource(file):
                 # If the file belongs to the source repo, ignore the p2
                 # since it will be covered by the existing fileset.
                 continue
 
             # If the file requires actual merging, abort. We don't have enough
             # context to resolve merges correctly.
             if action in mergestate.CONVERT_MERGE_ACTIONS:
                 raise error.Abort(
                     _(
                         b"unable to convert merge commit "
                         b"since target parents do not merge cleanly (file "
                         b"%s, parents %s and %s)"
                     )
                     % (file, p1ctx, p2ctx)
                 )
             elif action == mergestate.ACTION_KEEP:
                 # 'keep' means nothing changed from p1
                 continue
             else:
                 # Any other change means we want to take the p2 version
                 yield file
 
     def putcommit(
         self, files, copies, parents, commit, source, revmap, full, cleanp2
     ):
         files = dict(files)
 
         def getfilectx(repo, memctx, f):
             if p2ctx and f in p2files and f not in copies:
                 self.ui.debug(b'reusing %s from p2\n' % f)
                 try:
                     return p2ctx[f]
                 except error.ManifestLookupError:
                     # If the file doesn't exist in p2, then we're syncing a
                     # delete, so just return None.
                     return None
             try:
                 v = files[f]
             except KeyError:
                 return None
             data, mode = source.getfile(f, v)
             if data is None:
                 return None
             if f == b'.hgtags':
                 data = self._rewritetags(source, revmap, data)
             if f == b'.hgsubstate':
                 data = self._rewritesubstate(source, data)
             return context.memfilectx(
                 self.repo,
                 memctx,
                 f,
                 data,
                 b'l' in mode,
                 b'x' in mode,
                 copies.get(f),
             )
 
         pl = []
         for p in parents:
             if p not in pl:
                 pl.append(p)
         parents = pl
         nparents = len(parents)
         if self.filemapmode and nparents == 1:
             m1node = self.repo.changelog.read(bin(parents[0]))[0]
             parent = parents[0]
 
         if len(parents) < 2:
             parents.append(self.repo.nullid)
         if len(parents) < 2:
             parents.append(self.repo.nullid)
         p2 = parents.pop(0)
 
         text = commit.desc
 
         sha1s = re.findall(sha1re, text)
         for sha1 in sha1s:
             oldrev = source.lookuprev(sha1)
             newrev = revmap.get(oldrev)
             if newrev is not None:
                 text = text.replace(sha1, newrev[: len(sha1)])
 
         extra = commit.extra.copy()
 
         sourcename = self.repo.ui.config(b'convert', b'hg.sourcename')
         if sourcename:
             extra[b'convert_source'] = sourcename
 
         for label in (
             b'source',
             b'transplant_source',
             b'rebase_source',
             b'intermediate-source',
         ):
             node = extra.get(label)
 
             if node is None:
                 continue
 
             # Only transplant stores its reference in binary
             if label == b'transplant_source':
                 node = hex(node)
 
             newrev = revmap.get(node)
             if newrev is not None:
                 if label == b'transplant_source':
                     newrev = bin(newrev)
 
                 extra[label] = newrev
 
         if self.branchnames and commit.branch:
             extra[b'branch'] = commit.branch
         if commit.rev and commit.saverev:
             extra[b'convert_revision'] = commit.rev
 
         while parents:
             p1 = p2
             p2 = parents.pop(0)
             p1ctx = self.repo[p1]
             p2ctx = None
             if p2 != self.repo.nullid:
                 p2ctx = self.repo[p2]
             fileset = set(files)
             if full:
                 fileset.update(self.repo[p1])
                 fileset.update(self.repo[p2])
 
             if p2ctx:
                 p2files = set(cleanp2)
                 for file in self._calculatemergedfiles(source, p1ctx, p2ctx):
                     p2files.add(file)
                     fileset.add(file)
 
             ctx = context.memctx(
                 self.repo,
                 (p1, p2),
                 text,
                 fileset,
                 getfilectx,
                 commit.author,
                 commit.date,
                 extra,
             )
 
             # We won't know if the conversion changes the node until after the
             # commit, so copy the source's phase for now.
             self.repo.ui.setconfig(
                 b'phases',
                 b'new-commit',
                 phases.phasenames[commit.phase],
                 b'convert',
             )
 
             with self.repo.transaction(b"convert") as tr:
                 if self.repo.ui.config(b'convert', b'hg.preserve-hash'):
                     origctx = commit.ctx
                 else:
                     origctx = None
                 node = hex(self.repo.commitctx(ctx, origctx=origctx))
 
                 # If the node value has changed, but the phase is lower than
                 # draft, set it back to draft since it hasn't been exposed
                 # anywhere.
                 if commit.rev != node:
                     ctx = self.repo[node]
                     if ctx.phase() < phases.draft:
                         phases.registernew(
                             self.repo, tr, phases.draft, [ctx.rev()]
                         )
 
             text = b"(octopus merge fixup)\n"
             p2 = node
 
         if self.filemapmode and nparents == 1:
             man = self.repo.manifestlog.getstorage(b'')
             mnode = self.repo.changelog.read(bin(p2))[0]
             closed = b'close' in commit.extra
             if not closed and not man.cmp(m1node, man.revision(mnode)):
                 self.ui.status(_(b"filtering out empty revision\n"))
                 self.repo.rollback(force=True)
                 return parent
         return p2
 
     def puttags(self, tags):
         tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True)
         tagparent = tagparent or self.repo.nullid
 
         oldlines = set()
-        for branch, heads in pycompat.iteritems(self.repo.branchmap()):
+        for branch, heads in self.repo.branchmap().items():
             for h in heads:
                 if b'.hgtags' in self.repo[h]:
                     oldlines.update(
                         set(self.repo[h][b'.hgtags'].data().splitlines(True))
                     )
         oldlines = sorted(list(oldlines))
 
         newlines = sorted([(b"%s %s\n" % (tags[tag], tag)) for tag in tags])
         if newlines == oldlines:
             return None, None
 
         # if the old and new tags match, then there is nothing to update
         oldtags = set()
         newtags = set()
         for line in oldlines:
             s = line.strip().split(b' ', 1)
             if len(s) != 2:
                 continue
             oldtags.add(s[1])
         for line in newlines:
             s = line.strip().split(b' ', 1)
             if len(s) != 2:
                 continue
             if s[1] not in oldtags:
                 newtags.add(s[1].strip())
 
         if not newtags:
             return None, None
 
         data = b"".join(newlines)
 
         def getfilectx(repo, memctx, f):
             return context.memfilectx(repo, memctx, f, data, False, False, None)
 
         self.ui.status(_(b"updating tags\n"))
         date = b"%d 0" % int(time.mktime(time.gmtime()))
         extra = {b'branch': self.tagsbranch}
         ctx = context.memctx(
             self.repo,
             (tagparent, None),
             b"update tags",
             [b".hgtags"],
             getfilectx,
             b"convert-repo",
             date,
             extra,
         )
         node = self.repo.commitctx(ctx)
         return hex(node), hex(tagparent)
 
     def setfilemapmode(self, active):
         self.filemapmode = active
 
     def putbookmarks(self, updatedbookmark):
         if not len(updatedbookmark):
             return
         wlock = lock = tr = None
         try:
             wlock = self.repo.wlock()
             lock = self.repo.lock()
             tr = self.repo.transaction(b'bookmark')
             self.ui.status(_(b"updating bookmarks\n"))
             destmarks = self.repo._bookmarks
             changes = [
                 (bookmark, bin(updatedbookmark[bookmark]))
                 for bookmark in updatedbookmark
             ]
             destmarks.applychanges(self.repo, tr, changes)
             tr.close()
         finally:
             lockmod.release(lock, wlock, tr)
 
     def hascommitfrommap(self, rev):
         # the exact semantics of clonebranches is unclear so we can't say no
         return rev in self.repo or self.clonebranches
 
     def hascommitforsplicemap(self, rev):
         if rev not in self.repo and self.clonebranches:
             raise error.Abort(
                 _(
                     b'revision %s not found in destination '
                     b'repository (lookups with clonebranches=true '
                     b'are not implemented)'
                 )
                 % rev
             )
         return rev in self.repo
 
 
 class mercurial_source(common.converter_source):
     def __init__(self, ui, repotype, path, revs=None):
         common.converter_source.__init__(self, ui, repotype, path, revs)
         self.ignoreerrors = ui.configbool(b'convert', b'hg.ignoreerrors')
         self.ignored = set()
         self.saverev = ui.configbool(b'convert', b'hg.saverev')
         try:
             self.repo = hg.repository(self.ui, path)
             # try to provoke an exception if this isn't really a hg
             # repo, but some other bogus compatible-looking url
             if not self.repo.local():
                 raise error.RepoError
         except error.RepoError:
             ui.traceback()
             raise NoRepo(_(b"%s is not a local Mercurial repository") % path)
         self.lastrev = None
         self.lastctx = None
         self._changescache = None, None
         self.convertfp = None
         # Restrict converted revisions to startrev descendants
         startnode = ui.config(b'convert', b'hg.startrev')
         hgrevs = ui.config(b'convert', b'hg.revs')
         if hgrevs is None:
             if startnode is not None:
                 try:
                     startnode = self.repo.lookup(startnode)
                 except error.RepoError:
                     raise error.Abort(
                         _(b'%s is not a valid start revision') % startnode
                     )
                 startrev = self.repo.changelog.rev(startnode)
                 children = {startnode: 1}
                 for r in self.repo.changelog.descendants([startrev]):
                     children[self.repo.changelog.node(r)] = 1
                 self.keep = children.__contains__
             else:
                 self.keep = util.always
             if revs:
                 self._heads = [self.repo.lookup(r) for r in revs]
             else:
                 self._heads = self.repo.heads()
         else:
             if revs or startnode is not None:
                 raise error.Abort(
                     _(
                         b'hg.revs cannot be combined with '
                         b'hg.startrev or --rev'
                     )
                 )
             nodes = set()
             parents = set()
             for r in logcmdutil.revrange(self.repo, [hgrevs]):
                 ctx = self.repo[r]
                 nodes.add(ctx.node())
                 parents.update(p.node() for p in ctx.parents())
             self.keep = nodes.__contains__
             self._heads = nodes - parents
 
     def _changectx(self, rev):
         if self.lastrev != rev:
             self.lastctx = self.repo[rev]
             self.lastrev = rev
         return self.lastctx
 
     def _parents(self, ctx):
         return [p for p in ctx.parents() if p and self.keep(p.node())]
 
     def getheads(self):
         return [hex(h) for h in self._heads if self.keep(h)]
 
     def getfile(self, name, rev):
         try:
             fctx = self._changectx(rev)[name]
             return fctx.data(), fctx.flags()
         except error.LookupError:
             return None, None
 
     def _changedfiles(self, ctx1, ctx2):
         ma, r = [], []
         maappend = ma.append
         rappend = r.append
         d = ctx1.manifest().diff(ctx2.manifest())
         for f, ((node1, flag1), (node2, flag2)) in d.items():
             if node2 is None:
                 rappend(f)
             else:
                 maappend(f)
         return ma, r
 
     def getchanges(self, rev, full):
         ctx = self._changectx(rev)
         parents = self._parents(ctx)
         if full or not parents:
             files = copyfiles = ctx.manifest()
         if parents:
             if self._changescache[0] == rev:
                 ma, r = self._changescache[1]
             else:
                 ma, r = self._changedfiles(parents[0], ctx)
             if not full:
                 files = ma + r
             copyfiles = ma
         # _getcopies() is also run for roots and before filtering so missing
         # revlogs are detected early
         copies = self._getcopies(ctx, parents, copyfiles)
         cleanp2 = set()
         if len(parents) == 2:
             d = parents[1].manifest().diff(ctx.manifest(), clean=True)
             for f, value in d.items():
                 if value is None:
                     cleanp2.add(f)
         changes = [(f, rev) for f in files if f not in self.ignored]
         changes.sort()
         return changes, copies, cleanp2
 
     def _getcopies(self, ctx, parents, files):
         copies = {}
         for name in files:
             if name in self.ignored:
                 continue
             try:
                 copysource = ctx.filectx(name).copysource()
                 if copysource in self.ignored:
                     continue
                 # Ignore copy sources not in parent revisions
                 if not any(copysource in p for p in parents):
                     continue
                 copies[name] = copysource
             except TypeError:
                 pass
             except error.LookupError as e:
                 if not self.ignoreerrors:
                     raise
                 self.ignored.add(name)
                 self.ui.warn(_(b'ignoring: %s\n') % e)
         return copies
 
     def getcommit(self, rev):
         ctx = self._changectx(rev)
         _parents = self._parents(ctx)
         parents = [p.hex() for p in _parents]
         optparents = [p.hex() for p in ctx.parents() if p and p not in _parents]
         crev = rev
 
         return common.commit(
             author=ctx.user(),
             date=dateutil.datestr(ctx.date(), b'%Y-%m-%d %H:%M:%S %1%2'),
             desc=ctx.description(),
             rev=crev,
             parents=parents,
             optparents=optparents,
             branch=ctx.branch(),
             extra=ctx.extra(),
             sortkey=ctx.rev(),
             saverev=self.saverev,
             phase=ctx.phase(),
             ctx=ctx,
         )
 
     def numcommits(self):
         return len(self.repo)
 
     def gettags(self):
         # This will get written to .hgtags, filter non global tags out.
         tags = [
             t
             for t in self.repo.tagslist()
             if self.repo.tagtype(t[0]) == b'global'
         ]
         return {name: hex(node) for name, node in tags if self.keep(node)}
 
     def getchangedfiles(self, rev, i):
         ctx = self._changectx(rev)
         parents = self._parents(ctx)
         if not parents and i is None:
             i = 0
             ma, r = ctx.manifest().keys(), []
         else:
             i = i or 0
             ma, r = self._changedfiles(parents[i], ctx)
         ma, r = [[f for f in l if f not in self.ignored] for l in (ma, r)]
 
         if i == 0:
             self._changescache = (rev, (ma, r))
 
         return ma + r
 
     def converted(self, rev, destrev):
         if self.convertfp is None:
             self.convertfp = open(self.repo.vfs.join(b'shamap'), b'ab')
         self.convertfp.write(util.tonativeeol(b'%s %s\n' % (destrev, rev)))
         self.convertfp.flush()
 
     def before(self):
         self.ui.debug(b'run hg source pre-conversion action\n')
 
     def after(self):
         self.ui.debug(b'run hg source post-conversion action\n')
 
     def hasnativeorder(self):
         return True
 
     def hasnativeclose(self):
         return True
 
     def lookuprev(self, rev):
         try:
             return hex(self.repo.lookup(rev))
         except (error.RepoError, error.LookupError):
             return None
 
     def getbookmarks(self):
         return bookmarks.listbookmarks(self.repo)
 
     def checkrevformat(self, revstr, mapname=b'splicemap'):
         """Mercurial, revision string is a 40 byte hex"""
         self.checkhexformat(revstr, mapname)