git-remote-hg 1.0.2.1__py3-none-any.whl → 1.0.5__py3-none-any.whl

{git_remote_hg-1.0.2.1.data → git_remote_hg-1.0.5.data}/scripts/git-hg-helper

@@ -5,6 +5,11 @@
 
 from mercurial import hg, ui, commands, util
 from mercurial import context, subrepo
+try:
+    # hg >= 5.8
+    from mercurial.utils import urlutil
+except ImportError:
+    from mercurial import util as urlutil
 
 import re
 import sys
@@ -51,7 +56,13 @@ if sys.version_info[0] == 3:
         stdout = sys.stdout.buffer
         stderr = sys.stderr.buffer
         getcwd = os.getcwdb
-        getenv = os.getenvb if os.supports_bytes_environ else os.getenv
+        @staticmethod
+        def getenvb(val, default):
+            result = os.getenv(val.decode(), default.decode() if hasattr(default, 'decode') else default)
+             # if result is a string, get bytes instead
+            result = result.encode() if hasattr(result, 'encode') else result
+            return result
+        getenv = os.getenvb if os.supports_bytes_environ else getenvb
 else:
     class compat(basecompat):
         # life was simple in those days ...
@@ -86,11 +97,27 @@ def debug(msg, *args):
 def log(msg, *args):
     logger.log(logging.LOG, msg, *args)
 
+# new style way to import a source file
+def _imp_load_source(module_name, file_path):
+    import importlib.util
+    loader = importlib.machinery.SourceFileLoader(module_name, file_path)
+    spec = importlib.util.spec_from_loader(module_name, loader)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    return module
+
 def import_sibling(mod, filename):
-    import imp
     mydir = os.path.dirname(__file__)
     sys.dont_write_bytecode = True
-    return imp.load_source(mod, os.path.join(mydir, filename))
+    vi = sys.version_info
+    ff = os.path.join(mydir, filename)
+    if vi.major >= 3 and vi.minor >= 5:
+        return _imp_load_source(mod, ff)
+    else:
+        import imp
+        return imp.load_source(mod, ff)
+
 
 class GitHgRepo:
 
@@ -135,7 +162,7 @@ class GitHgRepo:
         process = self.start_cmd(args, **kwargs)
         output = process.communicate()[0]
         if check and process.returncode != 0:
-            die(b'command failed: %s' % b' '.join([compat.to_b(a) for a in cmd]))
+            die(b'git command failed: %s' % b' '.join([compat.to_b(a) for a in args]))
         return output
 
     def get_config(self, config, getall=False):
@@ -216,9 +243,12 @@ class GitHgRepo:
                         warn(b'failed to find local hg for remote %s' % (r))
                         continue
                 else:
+                    npath = os.path.abspath(hg_path)
+                    # use relative path if possible
+                    if check_version(4, 2):
+                        npath = os.path.join(b'..', b'..', b'..', b'.hg')
                     # make sure the shared path is always up-to-date
-                    util.writefile(os.path.join(local_hg, b'sharedpath'),
-                        os.path.abspath(hg_path))
+                    util.writefile(os.path.join(local_hg, b'sharedpath'), npath)
                 self.hg_repos[r] = os.path.join(local_path)
 
         log('%s determined hg_repos %s', self.identity(), self.hg_repos)
@@ -308,11 +338,11 @@ class GitHgRepo:
             if not kind in (b'hg', b'git'):
                 warn('skipping unsupported subrepo type %s' % kind)
                 continue
-            if not util.url(src).isabs():
+            if not urlutil.url(src).isabs():
                 parent = self.get_hg_repo_url(remote)
                 if not parent:
                     die(b'could not determine repo url of %s' % remote)
-                parent = util.url(parent)
+                parent = urlutil.url(parent)
                 parent.path = posixpath.join(parent.path or b'', src)
                 parent.path = posixpath.normpath(parent.path)
                 src = bytes(parent)
@@ -544,6 +574,43 @@ class GcCommand(SubCommand):
                 gm.store()
 
 
+class MapFileCommand(SubCommand):
+
+    def argumentparser(self):
+        usage = '%%(prog)s %s [options] <remote>' % (self.subcommand)
+        p = argparse.ArgumentParser(usage=usage)
+        p.add_argument('--output', required=True,
+            help='mapfile to write')
+        p.epilog = textwrap.dedent("""\
+        Writes a so-called git-mapfile, as used internally by hg-git.
+        This files consists of lines of format `<githexsha> <hghexsha>`.
+
+        As such, the result could be used to coax hg-git in some manner.
+        However, as git-remote-hg and hg-git may (likely) produce different
+        commits (either git or hg), mixed use of both tools is not recommended.
+        """)
+        return p
+
+    def do(self, options, args):
+        remotehg = import_sibling('remotehg', 'git-remote-hg')
+
+        if not args or len(args) != 1:
+            self.usage('expect 1 remote')
+
+        remote = args[0]
+        hgpath = remotehg.select_marks_dir(remote, self.githgrepo.gitdir, False)
+        puts(b"Loading hg marks ...")
+        hgm = remotehg.Marks(os.path.join(hgpath, b'marks-hg'), None)
+        puts(b"Loading git marks ...")
+        gm = GitMarks(os.path.join(hgpath, b'marks-git'))
+        puts(b"Writing mapfile ...")
+        with open(options.output, 'wb') as f:
+            for c, m in gm.marks.items():
+                hgc = hgm.rev_marks.get(m, None)
+                if hgc:
+                    f.write(b'%s %s\n' % (c, hgc))
+
+
 class SubRepoCommand(SubCommand):
 
     def writestate(repo, state):
@@ -910,6 +977,7 @@ def get_subcommands():
         b'repo': RepoCommand,
         b'gc':  GcCommand,
         b'sub': SubRepoCommand,
+        b'mapfile': MapFileCommand,
         b'help' : HelpCommand
     }
     # add remote named subcommands
@@ -932,6 +1000,7 @@ def do_usage():
     gc      \t perform maintenance and consistency cleanup on repo tracking marks
     sub     \t manage subrepos
     repo    \t show local hg repo backing a remote
+    mapfile \t dump a hg-git git-mapfile
 
     If the subcommand is the name of a remote hg repo, then any remaining arguments
     are considered a "hg command", e.g. hg heads, or thg, and it is then executed

{git_remote_hg-1.0.2.1.data → git_remote_hg-1.0.5.data}/scripts/git-remote-hg

@@ -86,7 +86,13 @@ if sys.version_info[0] == 3:
         stdout = sys.stdout.buffer
         stderr = sys.stderr.buffer
         getcwd = os.getcwdb
-        getenv = os.getenvb if os.supports_bytes_environ else os.getenv
+        @staticmethod
+        def getenvb(val, default):
+            result = os.getenv(val.decode(), default.decode() if hasattr(default, 'decode') else default)
+             # if result is a string, get bytes instead
+            result = result.encode() if hasattr(result, 'encode') else result
+            return result
+        getenv = os.getenvb if os.supports_bytes_environ else getenvb
         urlparse = urllib.parse.urlparse
         urljoin = urllib.parse.urljoin
 else:
@@ -116,6 +122,27 @@ else:
         urlparse = staticmethod(_urlparse)
         urljoin = staticmethod(_urljoin)
 
+# new style way to import a source file
+def _imp_load_source(module_name, file_path):
+    import importlib.util
+    loader = importlib.machinery.SourceFileLoader(module_name, file_path)
+    spec = importlib.util.spec_from_loader(module_name, loader)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    return module
+
+def import_sibling(mod, filename):
+    mydir = os.path.dirname(__file__)
+    sys.dont_write_bytecode = True
+    vi = sys.version_info
+    ff = os.path.join(mydir, filename)
+    if vi.major >= 3 and vi.minor >= 5:
+        return _imp_load_source(mod, ff)
+    else:
+        import imp
+        return imp.load_source(mod, ff)
+
 #
 # If you want to see Mercurial revisions as Git commit notes:
 # git config core.notesRef refs/notes/hg
@@ -141,11 +168,11 @@ else:
 # Commits are modified to preserve hg information and allow bidirectionality.
 #
 
-NAME_RE = re.compile(b'^([^<>]+)')
-AUTHOR_RE = re.compile(b'^([^<>]+?)? ?[<>]([^<>]*)(?:$|>)')
+NAME_RE = re.compile(br'^([^<>]+)')
+AUTHOR_RE = re.compile(br'^([^<>]+?)? ?[<>]([^<>]*)(?:$|>)')
 EMAIL_RE = re.compile(br'([^ \t<>]+@[^ \t<>]+)')
-AUTHOR_HG_RE = re.compile(b'^(.*?) ?<(.*?)(?:>(.*))?$')
-RAW_AUTHOR_RE = re.compile(b'^(\w+) (?:(.+)? )?<(.*)> (\d+) ([+-]\d+)')
+AUTHOR_HG_RE = re.compile(br'^(.*?) ?<(.*?)(?:>(.*))?$')
+RAW_AUTHOR_RE = re.compile(br'^(\w+) (?:(.+)? )?<(.*)> (\d+) ([+-]\d+)')
 
 VERSION = 2
 
@@ -153,6 +180,9 @@ def die(msg):
     compat.stderr.write(b'ERROR: %s\n' % compat.to_b(msg, 'utf-8'))
     sys.exit(1)
 
+def debug(*args):
+    compat.stderr.write(b'DEBUG: %s\n' % compat.to_b(repr(args)))
+
 def warn(msg):
     compat.stderr.write(b'WARNING: %s\n' % compat.to_b(msg, 'utf-8'))
     compat.stderr.flush()
@@ -193,7 +223,9 @@ def gitref(ref):
     # standard url percentage encoding with a (legacy) twist:
     # ' ' -> '___'
     # '___' also percentage encoded
-    return compat.urlquote(ref).replace(b'___', b'%5F%5F%5F').replace(b'%20', b'___')
+    # python 3.6 considers ~ reserved, whereas python 3.7 no longer
+    return compat.urlquote(ref).replace(b'___', b'%5F%5F%5F'). \
+        replace(b'%20', b'___').replace(b'~', b'%7E')
 
 def check_version(*check):
     if not hg_version:
@@ -229,27 +261,17 @@ def get_rev_hg(commit):
 
 class Marks:
 
-    def __init__(self, path, repo):
+    def __init__(self, path, _repo=None):
         self.path = path
-        self.repo = repo
         self.clear()
         self.load()
 
-        if self.version < VERSION:
-            if self.version == 1:
-                self.upgrade_one()
-
-            # upgraded?
-            if self.version < VERSION:
-                self.clear()
-                self.version = VERSION
-
     def clear(self):
         self.tips = {}
         self.marks = {}
         self.rev_marks = {}
         self.last_mark = 0
-        self.version = 0
+        self.version = VERSION
         self.last_note = 0
 
     def load(self):
@@ -265,20 +287,12 @@ class Marks:
         self.tips = []
         self.marks = marks
         self.last_mark = tmp['last-mark']
-        self.version = tmp.get('version', 1)
+        self.version = tmp['version']
         self.last_note = 0
 
         for rev, mark in compat.iteritems(self.marks):
             self.rev_marks[mark] = rev
 
-    def upgrade_one(self):
-        def get_id(rev):
-            return hghex(self.repo.changelog.node(int(rev)))
-        self.tips = dict((name, get_id(rev)) for name, rev in compat.iteritems(self.tips))
-        self.marks = dict((get_id(rev), mark) for rev, mark in compat.iteritems(self.marks))
-        self.rev_marks = dict((mark, get_id(rev)) for mark, rev in compat.iteritems(self.rev_marks))
-        self.version = 2
-
     def dict(self):
         return { 'tips': self.tips, 'marks': self.marks,
                 'last-mark': self.last_mark, 'version': self.version,
@@ -381,7 +395,7 @@ class Parser:
             return None
         _, name, email, date, tz = m.groups()
         if name and b'ext:' in name:
-            m = re.match(b'^(.+?) ext:\((.+)\)$', name)
+            m = re.match(br'^(.+?) ext:\((.+)\)$', name)
             if m:
                 name = m.group(1)
                 ex = compat.urlunquote(m.group(2))
@@ -400,40 +414,38 @@ class Parser:
         return (user, int(date), hgtz(tz))
 
 def fix_file_path(path):
-    def posix_path(path):
-        if os.sep == '/':
-            return path
-        # even Git for Windows expects forward
-        return path.replace(compat.to_b(os.sep), b'/')
-    # also converts forward slash to backwards slash on Win
     path = os.path.normpath(path)
-    if not os.path.isabs(path):
-        return posix_path(path)
-    return posix_path(os.path.relpath(path, b'/'))
-
-def export_files(files):
-    final = []
-    for f in files:
-        fid = node.hex(f.filenode())
-
-        if fid in filenodes:
-            mark = filenodes[fid]
-        else:
-            mark = marks.next_mark()
-            filenodes[fid] = mark
-            d = f.data()
-
-            puts(b"blob")
-            puts(b"mark :%u" % mark)
-            puts(b"data %d" % len(d))
-            puts(d)
+    if os.path.isabs(path):
+        path = os.path.relpath(path, b'/')
+    if os.sep == '/':
+        return path
+    # even Git for Windows expects forward
+    return path.replace(compat.to_b(os.sep), b'/')
+
+def export_file(ctx, fname):
+    f = ctx.filectx(fname)
+    fid = node.hex(f.filenode())
+
+    if fid in filenodes:
+        mark = filenodes[fid]
+    else:
+        mark = marks.next_mark()
+        filenodes[fid] = mark
+        d = f.data()
 
-        path = fix_file_path(f.path())
-        final.append((gitmode(f.flags()), mark, path))
+        puts(b"blob")
+        puts(b"mark :%u" % mark)
+        puts(b"data %d" % len(d))
+        puts(f.data())
 
-    return final
+    path = fixup_path_to_git(fix_file_path(f.path()))
+    return (gitmode(f.flags()), mark, path)
 
 def get_filechanges(repo, ctx, parent):
+    if hasattr(parent, 'status'):
+        stat = parent.status(ctx)
+        return stat.modified + stat.added, stat.removed
+
     modified = set()
     added = set()
     removed = set()
@@ -475,7 +487,7 @@ def fixup_user_git(user):
 def fixup_user_hg(user):
     def sanitize(name):
         # stole this from hg-git
-        return re.sub(b'[<>\n]', b'?', name.lstrip(b'< ').rstrip(b'> '))
+        return re.sub(br'[<>\n]', b'?', name.lstrip(b'< ').rstrip(b'> '))
 
     m = AUTHOR_HG_RE.match(user)
     if m:
@@ -506,6 +518,51 @@ def fixup_user(user):
 
     return b'%s <%s>' % (name, mail)
 
+# (recent) git fast-import does not accept .git or .gitmodule component names
+# (anywhere, case-insensitive)
+# in any case, surprising things may happen, so add some front-end replacement magic;
+# transform of (hg) .git(0 or more suffix) to (git) .git(1 or more suffix)
+# (likewise so for any invalid git keyword)
+def fixup_dotfile_path(path, suffix, add):
+    def subst(part):
+        if (not part) or part[0] != ord(b'.'):
+            return part
+        for prefix in (b'.git', b'.gitmodules'):
+            pl = len(prefix)
+            tail = len(part) - pl
+            if tail < 0:
+                continue
+            if part[0:pl].lower() == prefix and part[pl:] == suffix * tail:
+                if add:
+                    return part + suffix
+                elif tail == 0:
+                    # .git should not occur in git space
+                    # so complain
+                    if pl == 3:
+                        die('invalid path component %s' % part)
+                    else:
+                        # but .gitmodules might
+                        # leave as-is, it is handled/ignored elsewhere
+                        return part
+                else:
+                    return part[0:-1]
+        return part
+    # quick optimization check;
+    if (not path) or (path[0] != ord(b'.') and path.find(b'/.') < 0):
+        return path
+    sep = b'/'
+    return sep.join((subst(part) for part in path.split(sep)))
+
+def fixup_path_to_git(path):
+    if not dotfile_suffix:
+        return path
+    return fixup_dotfile_path(path, dotfile_suffix, True)
+
+def fixup_path_from_git(path):
+    if not dotfile_suffix:
+        return path
+    return fixup_dotfile_path(path, dotfile_suffix, False)
+
 def updatebookmarks(repo, peer):
     remotemarks = peer.listkeys(b'bookmarks')
 
@@ -577,18 +634,6 @@ def get_repo(url, alias):
     else:
         shared_path = os.path.join(gitdir, b'hg')
 
-        # check and upgrade old organization
-        hg_path = os.path.join(shared_path, b'.hg')
-        if os.path.exists(shared_path) and not os.path.exists(hg_path):
-            repos = os.listdir(shared_path)
-            for x in repos:
-                local_hg = os.path.join(shared_path, x, b'clone', b'.hg')
-                if not os.path.exists(local_hg):
-                    continue
-                if not os.path.exists(hg_path):
-                    shutil.move(local_hg, hg_path)
-                shutil.rmtree(os.path.join(shared_path, x, b'clone'))
-
         # setup shared repo (if not there)
         try:
             hg.peer(myui, {}, shared_path, create=True)
@@ -599,8 +644,13 @@ def get_repo(url, alias):
             os.makedirs(dirname)
 
         local_path = os.path.join(dirname, b'clone')
+        kwargs = {}
+        hg_path = os.path.join(shared_path, b'.hg')
+        if check_version(4, 2):
+            kwargs = {'relative': True}
+            hg_path = os.path.join(b'..', b'..', b'..', b'.hg')
         if not os.path.exists(local_path):
-            hg.share(myui, shared_path, local_path, update=False)
+            hg.share(myui, shared_path, local_path, update=False, **kwargs)
         else:
             # make sure the shared path is always up-to-date
             util.writefile(os.path.join(local_path, b'.hg', b'sharedpath'), hg_path)
@@ -709,11 +759,16 @@ def export_ref(repo, name, kind, head):
                 if rename:
                     renames.append((rename[0], f))
 
+            # NOTE no longer used in hg-git, a HG:rename extra header is used
             for e in renames:
                 extra_msg += b"rename : %s => %s\n" % e
 
             for key, value in compat.iteritems(extra):
-                if key in (b'author', b'committer', b'encoding', b'message', b'branch', b'hg-git'):
+                if key in (b'author', b'committer', b'encoding', b'message', b'branch', b'hg-git', b'transplant_source'):
+                    continue
+                elif key == b'hg-git-rename-source' and value == b'git':
+                    # extra data that hg-git might put there unconditionally
+                    # or that we put in there to be compatible
                     continue
                 else:
                     extra_msg += b"extra : %s : %s\n" % (key, compat.urlquote(value))
@@ -724,7 +779,7 @@ def export_ref(repo, name, kind, head):
         if len(parents) == 0:
             puts(b'reset %s/%s' % (prefix, ename))
 
-        modified_final = export_files(c.filectx(f) for f in modified)
+        modified_final = [export_file(c, fname) for fname in modified]
 
         puts(b"commit %s/%s" % (prefix, ename))
         puts(b"mark :%d" % (marks.get_mark(c.hex())))
@@ -739,7 +794,7 @@ def export_ref(repo, name, kind, head):
                 puts(b"merge :%u" % (rev_to_mark(parents[1])))
 
         for f in removed:
-            puts(b"D %s" % (fix_file_path(f)))
+            puts(b"D %s" % fixup_path_to_git(fix_file_path(f)))
         for f in modified_final:
             puts(b"M %s :%u %s" % f)
         puts()
@@ -837,8 +892,11 @@ def do_list(parser, branchmap):
 
     for branch, heads in compat.iteritems(branchmap):
         # only open heads
-        heads = [h for h in heads if b'close' not in repo.changelog.read(h)[5]]
-        if heads:
+        try:
+            heads = [h for h in heads if b'close' not in repo.changelog.read(h)[5]]
+            if heads:
+                branches[branch] = heads
+        except error.LookupError:
             branches[branch] = heads
 
     list_head(repo, cur)
@@ -1029,6 +1087,7 @@ def parse_commit(parser):
         else:
             die(b'Unknown file command: %s' % line)
         path = c_style_unescape(path)
+        path = fixup_path_from_git(path)
         files[path] = files.get(path, {})
         files[path].update(f)
 
@@ -1133,10 +1192,20 @@ def parse_commit(parser):
         extra[b'branch'] = hgref(branch)
 
     if mode == 'hg':
+        # add some extra that hg-git adds (almost) unconditionally
+        # see also https://foss.heptapod.net/mercurial/hg-git/-/merge_requests/211
+        # NOTE it could be changed to another value below
+        # actually, it is *almost* unconditionally, and only done if the commit
+        # is deduced to originate in git.  However, the latter is based on
+        # presence/absence of HG markers in commit "extra headers".
+        # The latter can not be handled here, and so this can not be correctly
+        # reproduced.
+        # extra[b'hg-git-rename-source'] = b'git'
         i = data.find(b'\n--HG--\n')
         if i >= 0:
             tmp = data[i + len(b'\n--HG--\n'):].strip()
             for k, v in [e.split(b' : ', 1) for e in tmp.split(b'\n')]:
+                # NOTE no longer used in hg-git, a HG:rename extra header is used
                 if k == b'rename':
                     old, new = v.split(b' => ', 1)
                     files[new]['rename'] = old
@@ -1324,7 +1393,10 @@ def checkheads(repo, remote, p_revs, force):
 def push_unsafe(repo, remote, p_revs, force):
 
     fci = discovery.findcommonincoming
-    commoninc = fci(repo, remote, force=force)
+    if check_version(4, 5):
+        commoninc = fci(repo, remote, force=force, ancestorsof=list(p_revs))
+    else:
+        commoninc = fci(repo, remote, force=force)
     common, _, remoteheads = commoninc
     fco = discovery.findcommonoutgoing
     outgoing = fco(repo, remote, onlyheads=list(p_revs), commoninc=commoninc, force=force)
@@ -1355,12 +1427,6 @@ def push_unsafe(repo, remote, p_revs, force):
     else:
         ret = remote.addchangegroup(cg, b'push', repo.url())
 
-    phases = remote.listkeys(b'phases')
-    if phases:
-        for head in p_revs:
-            # update to public
-            remote.pushkey(b'phases', hghex(head), b'1', b'0')
-
     return ret
 
 def push(repo, remote, p_revs, force):
@@ -1395,6 +1461,7 @@ def do_push_hg(parser):
     global parsed_refs, parsed_tags
     p_bmarks = []
     p_revs = {}
+    ok_refs = []
 
     parsed_refs = {}
     parsed_tags = {}
@@ -1441,7 +1508,7 @@ def do_push_hg(parser):
                 continue
 
             p_revs[bnode] = ref
-            puts(b"ok %s" % ref)
+            ok_refs.append(ref)
         elif ref.startswith(b'refs/heads/'):
             bmark = ref[len(b'refs/heads/'):]
             new = node
@@ -1451,14 +1518,14 @@ def do_push_hg(parser):
                 puts(b"ok %s up to date" % ref)
                 continue
 
-            puts(b"ok %s" % ref)
+            ok_refs.append(ref)
             if not bookmark_is_fake(bmark, parser.repo._bookmarks):
                 p_bmarks.append((ref, bmark, old, new))
 
             p_revs[bnode] = ref
         elif ref.startswith(b'refs/tags/'):
             if dry_run:
-                puts(b"ok %s" % ref)
+                ok_refs.append(ref)
                 continue
             tag = ref[len(b'refs/tags/'):]
             tag = hgref(tag)
@@ -1485,14 +1552,15 @@ def do_push_hg(parser):
                 fp.write(b'%s %s\n' % (node, tag))
                 fp.close()
             p_revs[bnode] = ref
-            puts(b"ok %s" % ref)
+            ok_refs.append(ref)
         else:
             # transport-helper/fast-export bugs
             continue
 
     if dry_run:
-        if peer:
-            checkheads(parser.repo, peer, p_revs, force_push)
+        if not peer or checkheads(parser.repo, peer, p_revs, force_push):
+            for ref in ok_refs:
+                puts(b"ok %s" % ref)
         return
 
     success = True
@@ -1513,12 +1581,18 @@ def do_push_hg(parser):
             if not peer.pushkey(b'bookmarks', bmark, old, new):
                 success = False
                 puts(b"error %s" % ref)
+                ok_refs.remove(ref)
     else:
         # update local bookmarks
         for ref, bmark, old, new in p_bmarks:
             if not bookmarks.pushbookmark(parser.repo, bmark, old, new):
                 success = False
                 puts(b"error %s" % ref)
+                ok_refs.remove(ref)
+
+    # update rest of the refs
+    for ref in ok_refs:
+        puts(b"ok %s" % ref)
 
     return success
 
@@ -1602,10 +1676,7 @@ def do_push_refspec(parser, refspec, revs):
             tmpfastexport = open(os.path.join(marksdir, b'git-fast-export-%d' % (os.getpid())), 'w+b')
             subprocess.check_call(cmd, stdin=None, stdout=tmpfastexport)
             try:
-                import imp
-                sys.dont_write_bytecode = True
-                ctx.hghelper = imp.load_source('hghelper', \
-                    os.path.join(os.path.dirname(__file__), 'git-hg-helper'))
+                ctx.hghelper = import_sibling('hghelper', 'git-hg-helper')
                 ctx.hghelper.init_git(gitdir)
                 ctx.gitmarks = ctx.hghelper.GitMarks(tmpmarks)
                 # let processing know it should not bother pushing if not requested
@@ -1727,8 +1798,7 @@ def fix_path(alias, repo, orig_url):
     url = compat.urlparse(orig_url, b'file')
     if url.scheme != b'file' or os.path.isabs(os.path.expanduser(url.path)):
         return
-    abs_url = compat.urljoin(b"%s/" % compat.getcwd(), orig_url)
-    cmd = ['git', 'config', b'remote.%s.url' % alias, b"hg::%s" % abs_url]
+    cmd = ['git', 'config', b'remote.%s.url' % alias, b"hg::%s" % os.path.abspath(orig_url)]
     subprocess.call(cmd)
 
 def select_private_refs(alias):
@@ -1843,6 +1913,7 @@ def main(args):
     global capability_push
     global remove_username_quotes
     global marksdir
+    global dotfile_suffix
 
     marks = None
     is_tmp = False
@@ -1862,6 +1933,7 @@ def main(args):
     track_branches = get_config_bool('remote-hg.track-branches', True)
     capability_push = get_config_bool('remote-hg.capability-push', True)
     remove_username_quotes = get_config_bool('remote-hg.remove-username-quotes', True)
+    dotfile_suffix = get_config('remote-hg.dotfile-suffix').strip() or b'_'
     force_push = False
 
     if hg_git_compat:
@@ -1906,7 +1978,7 @@ def main(args):
         fix_path(alias, peer or repo, url)
 
     marks_path = os.path.join(marksdir, b'marks-hg')
-    marks = Marks(marks_path, repo)
+    marks = Marks(marks_path)
 
     if sys.platform == 'win32':
         import msvcrt

{git_remote_hg-1.0.2.1.dist-info → git_remote_hg-1.0.5.dist-info}/METADATA

@@ -1,13 +1,12 @@
-Metadata-Version: 2.0
+Metadata-Version: 2.4
 Name: git-remote-hg
-Version: 1.0.2.1
+Version: 1.0.5
 Summary: access hg repositories as git remotes
 Home-page: http://github.com/mnauw/git-remote-hg
 Author: Mark Nauwelaerts
 Author-email: mnauw@users.sourceforge.net
 License: GPLv2
 Keywords: git hg mercurial
-Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 2.7
@@ -17,6 +16,16 @@ Classifier: License :: OSI Approved
 Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
 
 
 'git-remote-hg' is a gitremote protocol helper for Mercurial.
@@ -24,5 +33,3 @@ It allows you to clone, fetch and push to and from Mercurial repositories as if
 they were Git ones using a hg::some-url URL.
 
 See the homepage for much more explanation.
-
-

git_remote_hg-1.0.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+git_remote_hg-1.0.5.data/scripts/git-hg-helper,sha256=O0EqXGlnKvy2iZmC1yjYs8r6ngGhKYDEitcYxk1zp-g,41579
+git_remote_hg-1.0.5.data/scripts/git-remote-hg,sha256=ULECiK_-vLDIKwyv1_wudE2cVPTyFR7pPEUjnf8aWXw,65795
+git_remote_hg-1.0.5.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+p3/bin/activate_this.py,sha256=MQBgepC7N5S_OdxDTvSVYQ7TIkx89a3JqCrGqpXU0lY,1137
+git_remote_hg-1.0.5.dist-info/METADATA,sha256=yHU6kloORtYMXUboM_wg7bzWyEoJ64OIrhOJV3HkBQ8,1142
+git_remote_hg-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+git_remote_hg-1.0.5.dist-info/top_level.txt,sha256=k-m8stlTG4vntq0sHGPphyBQomUDHq-qAkPlcHj9_XQ,3
+git_remote_hg-1.0.5.dist-info/RECORD,,

{git_remote_hg-1.0.2.1.dist-info → git_remote_hg-1.0.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.30.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

git_remote_hg-1.0.5.dist-info/licenses/LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

git_remote_hg-1.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+p3

p3/bin/activate_this.py

@@ -0,0 +1,34 @@
+"""By using execfile(this_file, dict(__file__=this_file)) you will
+activate this virtualenv environment.
+
+This can be used when you must use an existing Python interpreter, not
+the virtualenv bin/python
+"""
+
+try:
+    __file__
+except NameError:
+    raise AssertionError(
+        "You must run this like execfile('path/to/activate_this.py', dict(__file__='path/to/activate_this.py'))")
+import sys
+import os
+
+old_os_path = os.environ.get('PATH', '')
+os.environ['PATH'] = os.path.dirname(os.path.abspath(__file__)) + os.pathsep + old_os_path
+base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if sys.platform == 'win32':
+    site_packages = os.path.join(base, 'Lib', 'site-packages')
+else:
+    site_packages = os.path.join(base, 'lib', 'python%s' % sys.version[:3], 'site-packages')
+prev_sys_path = list(sys.path)
+import site
+site.addsitedir(site_packages)
+sys.real_prefix = sys.prefix
+sys.prefix = base
+# Move the added items to the front of the path:
+new_sys_path = []
+for item in list(sys.path):
+    if item not in prev_sys_path:
+        new_sys_path.append(item)
+        sys.path.remove(item)
+sys.path[:0] = new_sys_path

git_remote_hg-1.0.2.1.dist-info/DESCRIPTION.rst

@@ -1,8 +0,0 @@
-
-'git-remote-hg' is a gitremote protocol helper for Mercurial.
-It allows you to clone, fetch and push to and from Mercurial repositories as if
-they were Git ones using a hg::some-url URL.
-
-See the homepage for much more explanation.
-
-

git_remote_hg-1.0.2.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-git_remote_hg-1.0.2.1.data/scripts/git-hg-helper,sha256=IkCQLilV4hmgY0JIYHOTgvxJEFjJQofsCYwI8i6RojQ,38879
-git_remote_hg-1.0.2.1.data/scripts/git-remote-hg,sha256=ALWYryFBcWCjFl_fsvEJexYEsg4Fld8VpOfGGGPIZRk,62714
-git_remote_hg-1.0.2.1.dist-info/DESCRIPTION.rst,sha256=1WcbxashBdLLnl_yTmeoJIX8GmlhOirBUJwbGiWi5eQ,235
-git_remote_hg-1.0.2.1.dist-info/METADATA,sha256=0K6UZYodQ0D8Z5Lc3FrO10bINX1AsxxI9nkpLAePy5o,970
-git_remote_hg-1.0.2.1.dist-info/RECORD,,
-git_remote_hg-1.0.2.1.dist-info/WHEEL,sha256=8Lm45v9gcYRm70DrgFGVe4WsUtUMi1_0Tso1hqPGMjA,92
-git_remote_hg-1.0.2.1.dist-info/metadata.json,sha256=3oh-cdfNjurg6m3Cgp7ZkmfOSGybUqzWmccbZjUKtgg,870
-git_remote_hg-1.0.2.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1

git_remote_hg-1.0.2.1.dist-info/metadata.json

@@ -1 +0,0 @@
-{"classifiers": ["Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.6", "License :: OSI Approved", "License :: OSI Approved :: GNU General Public License v2 (GPLv2)", "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers"], "extensions": {"python.details": {"contacts": [{"email": "mnauw@users.sourceforge.net", "name": "Mark Nauwelaerts", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "http://github.com/mnauw/git-remote-hg"}}}, "generator": "bdist_wheel (0.30.0)", "keywords": ["git", "hg", "mercurial"], "license": "GPLv2", "metadata_version": "2.0", "name": "git-remote-hg", "summary": "access hg repositories as git remotes", "version": "1.0.2.1"}

git_remote_hg-1.0.2.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-