contrib: revsetbenchmarks use absolute_import and print_function

contrib/revsetbenchmarks.py

@@ -1,325 +1,334 b''
 #!/usr/bin/env python
 
 # Measure the performance of a list of revsets against multiple revisions
 # defined by parameter. Checkout one by one and run perfrevset with every
 # revset in the list to benchmark its performance.
 #
 # You should run this from the root of your mercurial repository.
 #
 # call with --help for details
 
-import sys
+from __future__ import absolute_import, print_function
+import math
 import os
 import re
-import math
-from subprocess import check_call, Popen, CalledProcessError, STDOUT, PIPE
+import sys
+from subprocess import (
+    CalledProcessError,
+    check_call,
+    PIPE,
+    Popen,
+    STDOUT,
+)
 # cannot use argparse, python 2.7 only
-from optparse import OptionParser
+from optparse import (
+    OptionParser,
+)
 
 DEFAULTVARIANTS = ['plain', 'min', 'max', 'first', 'last',
                    'reverse', 'reverse+first', 'reverse+last',
                    'sort', 'sort+first', 'sort+last']
 
 def check_output(*args, **kwargs):
     kwargs.setdefault('stderr', PIPE)
     kwargs.setdefault('stdout', PIPE)
     proc = Popen(*args, **kwargs)
     output, error = proc.communicate()
     if proc.returncode != 0:
         raise CalledProcessError(proc.returncode, ' '.join(args[0]))
     return output
 
 def update(rev):
     """update the repo to a revision"""
     try:
         check_call(['hg', 'update', '--quiet', '--check', str(rev)])
         check_output(['make', 'local'],
                      stderr=None)  # suppress output except for error/warning
     except CalledProcessError as exc:
-        print >> sys.stderr, 'update to revision %s failed, aborting' % rev
+        print('update to revision %s failed, aborting'%rev, file=sys.stderr)
         sys.exit(exc.returncode)
 
 
 def hg(cmd, repo=None):
     """run a mercurial command
 
     <cmd> is the list of command + argument,
     <repo> is an optional repository path to run this command in."""
     fullcmd = ['./hg']
     if repo is not None:
         fullcmd += ['-R', repo]
     fullcmd += ['--config',
                 'extensions.perf=' + os.path.join(contribdir, 'perf.py')]
     fullcmd += cmd
     return check_output(fullcmd, stderr=STDOUT)
 
 def perf(revset, target=None, contexts=False):
     """run benchmark for this very revset"""
     try:
         args = ['perfrevset', revset]
         if contexts:
             args.append('--contexts')
         output = hg(args, repo=target)
         return parseoutput(output)
     except CalledProcessError as exc:
-        print >> sys.stderr, 'abort: cannot run revset benchmark: %s' % exc.cmd
+        print('abort: cannot run revset benchmark: %s'%exc.cmd, file=sys.stderr)
         if getattr(exc, 'output', None) is None: # no output before 2.7
-            print >> sys.stderr, '(no output)'
+            print('(no output)', file=sys.stderr)
         else:
-            print >> sys.stderr, exc.output
+            print(exc.output, file=sys.stderr)
         return None
 
 outputre = re.compile(r'! wall (\d+.\d+) comb (\d+.\d+) user (\d+.\d+) '
                       'sys (\d+.\d+) \(best of (\d+)\)')
 
 def parseoutput(output):
     """parse a textual output into a dict
 
     We cannot just use json because we want to compare with old
     versions of Mercurial that may not support json output.
     """
     match = outputre.search(output)
     if not match:
-        print >> sys.stderr, 'abort: invalid output:'
-        print >> sys.stderr, output
+        print('abort: invalid output:', file=sys.stderr)
+        print(output, file=sys.stderr)
         sys.exit(1)
     return {'comb': float(match.group(2)),
             'count': int(match.group(5)),
             'sys': float(match.group(3)),
             'user': float(match.group(4)),
             'wall': float(match.group(1)),
             }
 
 def printrevision(rev):
     """print data about a revision"""
     sys.stdout.write("Revision ")
     sys.stdout.flush()
     check_call(['hg', 'log', '--rev', str(rev), '--template',
                 '{if(tags, " ({tags})")} '
                 '{rev}:{node|short}: {desc|firstline}\n'])
 
 def idxwidth(nbidx):
     """return the max width of number used for index
 
     This is similar to log10(nbidx), but we use custom code here
     because we start with zero and we'd rather not deal with all the
     extra rounding business that log10 would imply.
     """
     nbidx -= 1 # starts at 0
     idxwidth = 0
     while nbidx:
         idxwidth += 1
         nbidx //= 10
     if not idxwidth:
         idxwidth = 1
     return idxwidth
 
 def getfactor(main, other, field, sensitivity=0.05):
     """return the relative factor between values for 'field' in main and other
 
     Return None if the factor is insignificant (less than <sensitivity>
     variation)."""
     factor = 1
     if main is not None:
         factor = other[field] / main[field]
     low, high = 1 - sensitivity, 1 + sensitivity
     if (low < factor < high):
         return None
     return factor
 
 def formatfactor(factor):
     """format a factor into a 4 char string
 
      22%
     156%
     x2.4
      x23
     x789
     x1e4
     x5x7
 
     """
     if factor is None:
         return '    '
     elif factor < 2:
         return '%3i%%' % (factor * 100)
     elif factor < 10:
         return 'x%3.1f' % factor
     elif factor < 1000:
         return '%4s' % ('x%i' % factor)
     else:
         order = int(math.log(factor)) + 1
         while 1 < math.log(factor):
             factor //= 0
         return 'x%ix%i' % (factor, order)
 
 def formattiming(value):
     """format a value to strictly 8 char, dropping some precision if needed"""
     if value < 10**7:
         return ('%.6f' % value)[:8]
     else:
         # value is HUGE very unlikely to happen (4+ month run)
         return '%i' % value
 
 _marker = object()
 def printresult(variants, idx, data, maxidx, verbose=False, reference=_marker):
     """print a line of result to stdout"""
     mask = '%%0%ii) %%s' % idxwidth(maxidx)
 
     out = []
     for var in variants:
         if data[var] is None:
             out.append('error   ')
             out.append(' ' * 4)
             continue
         out.append(formattiming(data[var]['wall']))
         if reference is not _marker:
             factor = None
             if reference is not None:
                 factor = getfactor(reference[var], data[var], 'wall')
             out.append(formatfactor(factor))
         if verbose:
             out.append(formattiming(data[var]['comb']))
             out.append(formattiming(data[var]['user']))
             out.append(formattiming(data[var]['sys']))
             out.append('%6d'    % data[var]['count'])
-    print mask % (idx, ' '.join(out))
+    print(mask % (idx, ' '.join(out)))
 
 def printheader(variants, maxidx, verbose=False, relative=False):
     header = [' ' * (idxwidth(maxidx) + 1)]
     for var in variants:
         if not var:
             var = 'iter'
         if 8 < len(var):
             var = var[:3] + '..' + var[-3:]
         header.append('%-8s' % var)
         if relative:
             header.append('    ')
         if verbose:
             header.append('%-8s' % 'comb')
             header.append('%-8s' % 'user')
             header.append('%-8s' % 'sys')
             header.append('%6s' % 'count')
-    print ' '.join(header)
+    print(' '.join(header))
 
 def getrevs(spec):
     """get the list of rev matched by a revset"""
     try:
         out = check_output(['hg', 'log', '--template={rev}\n', '--rev', spec])
     except CalledProcessError as exc:
-        print >> sys.stderr, "abort, can't get revision from %s" % spec
+        print("abort, can't get revision from %s"%spec, file=sys.stderr)
         sys.exit(exc.returncode)
     return [r for r in out.split() if r]
 
 
 def applyvariants(revset, variant):
     if variant == 'plain':
         return revset
     for var in variant.split('+'):
         revset = '%s(%s)' % (var, revset)
     return revset
 
 helptext="""This script will run multiple variants of provided revsets using
 different revisions in your mercurial repository. After the benchmark are run
 summary output is provided. Use it to demonstrate speed improvements or pin
 point regressions. Revsets to run are specified in a file (or from stdin), one
 revsets per line. Line starting with '#' will be ignored, allowing insertion of
 comments."""
 parser = OptionParser(usage="usage: %prog [options] <revs>",
                       description=helptext)
 parser.add_option("-f", "--file",
                   help="read revset from FILE (stdin if omitted)",
                   metavar="FILE")
 parser.add_option("-R", "--repo",
                   help="run benchmark on REPO", metavar="REPO")
 
 parser.add_option("-v", "--verbose",
                   action='store_true',
                   help="display all timing data (not just best total time)")
 
 parser.add_option("", "--variants",
                   default=','.join(DEFAULTVARIANTS),
                   help="comma separated list of variant to test "
                        "(eg: plain,min,sorted) (plain = no modification)")
 parser.add_option('', '--contexts',
                   action='store_true',
                   help='obtain changectx from results instead of integer revs')
 
 (options, args) = parser.parse_args()
 
 if not args:
     parser.print_help()
     sys.exit(255)
 
 # the directory where both this script and the perf.py extension live.
 contribdir = os.path.dirname(__file__)
 
 revsetsfile = sys.stdin
 if options.file:
     revsetsfile = open(options.file)
 
 revsets = [l.strip() for l in revsetsfile if not l.startswith('#')]
 revsets = [l for l in revsets if l]
 
-print "Revsets to benchmark"
-print "----------------------------"
+print("Revsets to benchmark")
+print("----------------------------")
 
 for idx, rset in enumerate(revsets):
-    print "%i) %s" % (idx, rset)
+    print("%i) %s" % (idx, rset))
 
-print "----------------------------"
-print
+print("----------------------------")
+print()
 
 revs = []
 for a in args:
     revs.extend(getrevs(a))
 
 variants = options.variants.split(',')
 
 results = []
 for r in revs:
-    print "----------------------------"
+    print("----------------------------")
     printrevision(r)
-    print "----------------------------"
+    print("----------------------------")
     update(r)
     res = []
     results.append(res)
     printheader(variants, len(revsets), verbose=options.verbose)
     for idx, rset in enumerate(revsets):
         varres = {}
         for var in variants:
             varrset = applyvariants(rset, var)
             data = perf(varrset, target=options.repo, contexts=options.contexts)
             varres[var] = data
         res.append(varres)
         printresult(variants, idx, varres, len(revsets),
                     verbose=options.verbose)
         sys.stdout.flush()
-    print "----------------------------"
+    print("----------------------------")
 
 
-print """
+print("""
 
 Result by revset
 ================
-"""
+""")
 
-print 'Revision:'
+print('Revision:')
 for idx, rev in enumerate(revs):
     sys.stdout.write('%i) ' % idx)
     sys.stdout.flush()
     printrevision(rev)
 
-print
-print
+print()
+print()
 
 for ridx, rset in enumerate(revsets):
 
-    print "revset #%i: %s" % (ridx, rset)
+    print("revset #%i: %s" % (ridx, rset))
     printheader(variants, len(results), verbose=options.verbose, relative=True)
     ref = None
     for idx, data in enumerate(results):
         printresult(variants, idx, data[ridx], len(results),
                     verbose=options.verbose, reference=ref)
         ref = data[ridx]
-    print
+    print()

tests/test-check-py3-compat.t

@@ -1,122 +1,120 b''
 #require test-repo
 
   $ cd "$TESTDIR"/..
 
   $ hg files 'set:(**.py)' | sed 's|\\|/|g' | xargs python contrib/check-py3-compat.py
   contrib/import-checker.py not using absolute_import
   contrib/import-checker.py requires print_function
-  contrib/revsetbenchmarks.py not using absolute_import
-  contrib/revsetbenchmarks.py requires print_function
   doc/check-seclevel.py not using absolute_import
   doc/gendoc.py not using absolute_import
   doc/hgmanpage.py not using absolute_import
   hgext/color.py not using absolute_import
   hgext/eol.py not using absolute_import
   hgext/extdiff.py not using absolute_import
   hgext/factotum.py not using absolute_import
   hgext/fetch.py not using absolute_import
   hgext/fsmonitor/pywatchman/__init__.py not using absolute_import
   hgext/fsmonitor/pywatchman/__init__.py requires print_function
   hgext/fsmonitor/pywatchman/capabilities.py not using absolute_import
   hgext/fsmonitor/pywatchman/pybser.py not using absolute_import
   hgext/gpg.py not using absolute_import
   hgext/graphlog.py not using absolute_import
   hgext/hgcia.py not using absolute_import
   hgext/hgk.py not using absolute_import
   hgext/highlight/__init__.py not using absolute_import
   hgext/highlight/highlight.py not using absolute_import
   hgext/histedit.py not using absolute_import
   hgext/largefiles/__init__.py not using absolute_import
   hgext/largefiles/basestore.py not using absolute_import
   hgext/largefiles/lfcommands.py not using absolute_import
   hgext/largefiles/lfutil.py not using absolute_import
   hgext/largefiles/localstore.py not using absolute_import
   hgext/largefiles/overrides.py not using absolute_import
   hgext/largefiles/proto.py not using absolute_import
   hgext/largefiles/remotestore.py not using absolute_import
   hgext/largefiles/reposetup.py not using absolute_import
   hgext/largefiles/uisetup.py not using absolute_import
   hgext/largefiles/wirestore.py not using absolute_import
   hgext/mq.py not using absolute_import
   hgext/rebase.py not using absolute_import
   hgext/share.py not using absolute_import
   hgext/win32text.py not using absolute_import
   i18n/check-translation.py not using absolute_import
   i18n/polib.py not using absolute_import
   setup.py not using absolute_import
   tests/filterpyflakes.py requires print_function
   tests/generate-working-copy-states.py requires print_function
   tests/get-with-headers.py requires print_function
   tests/heredoctest.py requires print_function
   tests/hypothesishelpers.py not using absolute_import
   tests/hypothesishelpers.py requires print_function
   tests/killdaemons.py not using absolute_import
   tests/md5sum.py not using absolute_import
   tests/mockblackbox.py not using absolute_import
   tests/printenv.py not using absolute_import
   tests/readlink.py not using absolute_import
   tests/readlink.py requires print_function
   tests/revlog-formatv0.py not using absolute_import
   tests/run-tests.py not using absolute_import
   tests/seq.py not using absolute_import
   tests/seq.py requires print_function
   tests/silenttestrunner.py not using absolute_import
   tests/silenttestrunner.py requires print_function
   tests/sitecustomize.py not using absolute_import
   tests/svn-safe-append.py not using absolute_import
   tests/svnxml.py not using absolute_import
   tests/test-ancestor.py requires print_function
   tests/test-atomictempfile.py not using absolute_import
   tests/test-batching.py not using absolute_import
   tests/test-batching.py requires print_function
   tests/test-bdiff.py not using absolute_import
   tests/test-bdiff.py requires print_function
   tests/test-context.py not using absolute_import
   tests/test-context.py requires print_function
   tests/test-demandimport.py not using absolute_import
   tests/test-demandimport.py requires print_function
   tests/test-doctest.py not using absolute_import
   tests/test-duplicateoptions.py not using absolute_import
   tests/test-duplicateoptions.py requires print_function
   tests/test-filecache.py not using absolute_import
   tests/test-filecache.py requires print_function
   tests/test-filelog.py not using absolute_import
   tests/test-filelog.py requires print_function
   tests/test-hg-parseurl.py not using absolute_import
   tests/test-hg-parseurl.py requires print_function
   tests/test-hgweb-auth.py not using absolute_import
   tests/test-hgweb-auth.py requires print_function
   tests/test-hgwebdir-paths.py not using absolute_import
   tests/test-hybridencode.py not using absolute_import
   tests/test-hybridencode.py requires print_function
   tests/test-lrucachedict.py not using absolute_import
   tests/test-lrucachedict.py requires print_function
   tests/test-manifest.py not using absolute_import
   tests/test-minirst.py not using absolute_import
   tests/test-minirst.py requires print_function
   tests/test-parseindex2.py not using absolute_import
   tests/test-parseindex2.py requires print_function
   tests/test-pathencode.py not using absolute_import
   tests/test-pathencode.py requires print_function
   tests/test-propertycache.py not using absolute_import
   tests/test-propertycache.py requires print_function
   tests/test-revlog-ancestry.py not using absolute_import
   tests/test-revlog-ancestry.py requires print_function
   tests/test-run-tests.py not using absolute_import
   tests/test-simplemerge.py not using absolute_import
   tests/test-status-inprocess.py not using absolute_import
   tests/test-status-inprocess.py requires print_function
   tests/test-symlink-os-yes-fs-no.py not using absolute_import
   tests/test-trusted.py not using absolute_import
   tests/test-trusted.py requires print_function
   tests/test-ui-color.py not using absolute_import
   tests/test-ui-color.py requires print_function
   tests/test-ui-config.py not using absolute_import
   tests/test-ui-config.py requires print_function
   tests/test-ui-verbosity.py not using absolute_import
   tests/test-ui-verbosity.py requires print_function
   tests/test-url.py not using absolute_import
   tests/test-url.py requires print_function
   tests/test-walkrepo.py requires print_function
   tests/test-wireproto.py requires print_function
   tests/tinyproxy.py requires print_function