Upgrade to coverage 3.7.1 and have it auto-build itself on first use.

third_party/coverage-3.7.1/coverage/cmdline.py

 """Command-line support for Coverage."""
 
-import optparse, sys, traceback
+import optparse, os, sys, time, traceback
 
 from coverage.backward import sorted                # pylint: disable=W0622
 from coverage.execfile import run_python_file, run_python_module
 from coverage.misc import CoverageException, ExceptionDuringRun, NoSource
+from coverage.debug import info_formatter
 
 
 class Opts(object):
     """A namespace class for individual options we'll build parsers from."""
 
     append = optparse.make_option(
         '-a', '--append', action='store_false', dest="erase_first",
         help="Append coverage data to .coverage, otherwise it is started "
                 "clean with each run."
         )
     branch = optparse.make_option(
         '', '--branch', action='store_true',
         help="Measure branch coverage in addition to statement coverage."
         )
+    debug = optparse.make_option(
+        '', '--debug', action='store', metavar="OPTS",
+        help="Debug options, separated by commas"
+        )
     directory = optparse.make_option(
         '-d', '--directory', action='store', metavar="DIR",
         help="Write the output files to DIR."
         )
     fail_under = optparse.make_option(
         '', '--fail-under', action='store', metavar="MIN", type="int",
         help="Exit with a status of 2 if the total coverage is less than MIN."
         )
     help = optparse.make_option(
         '-h', '--help', action='store_true',
@@ skipping 78 matching lines @@
 
     """
 
     def __init__(self, *args, **kwargs):
         super(CoverageOptionParser, self).__init__(
             add_help_option=False, *args, **kwargs
             )
         self.set_defaults(
             actions=[],
             branch=None,
+            debug=None,
             directory=None,
             fail_under=None,
             help=None,
             ignore_errors=None,
             include=None,
             omit=None,
             parallel_mode=None,
             module=None,
             pylib=None,
             rcfile=True,
@@ skipping 173 matching lines @@
             Opts.show_missing,
             ] + GLOBAL_ARGS,
         usage = "[options] [modules]",
         description = "Report coverage statistics on modules."
         ),
 
     'run': CmdOptionParser("execute",
         [
             Opts.append,
             Opts.branch,
+            Opts.debug,
             Opts.pylib,
             Opts.parallel_mode,
             Opts.module,
             Opts.timid,
             Opts.source,
             Opts.omit,
             Opts.include,
             ] + GLOBAL_ARGS,
         defaults = {'erase_first': True},
         cmd = "run",
@@ skipping 74 matching lines @@
             return OK
 
         # Check for conflicts and problems in the options.
         if not self.args_ok(options, args):
             return ERR
 
         # Listify the list options.
         source = unshell_list(options.source)
         omit = unshell_list(options.omit)
         include = unshell_list(options.include)
+        debug = unshell_list(options.debug)
 
         # Do something.
         self.coverage = self.covpkg.coverage(
             data_suffix = options.parallel_mode,
             cover_pylib = options.pylib,
             timid = options.timid,
             branch = options.branch,
             config_file = options.rcfile,
             source = source,
             omit = omit,
             include = include,
+            debug = debug,
             )
 
         if 'debug' in options.actions:
             return self.do_debug(args)
 
         if 'erase' in options.actions or options.erase_first:
             self.coverage.erase()
         else:
             self.coverage.load()
 
@@ skipping 114 matching lines @@
 
         if 'execute' in options.actions and not args:
             self.help_fn("Nothing to do.")
             return False
 
         return True
 
     def do_execute(self, options, args):
         """Implementation of 'coverage run'."""
 
+        # Set the first path element properly.
+        old_path0 = sys.path[0]
+
         # Run the script.
         self.coverage.start()
         code_ran = True
         try:
             try:
                 if options.module:
+                    sys.path[0] = ''
                     self.run_python_module(args[0], args)
                 else:
-                    self.run_python_file(args[0], args)
+                    filename = args[0]
+                    sys.path[0] = os.path.abspath(os.path.dirname(filename))
+                    self.run_python_file(filename, args)
             except NoSource:
                 code_ran = False
                 raise
         finally:
             self.coverage.stop()
             if code_ran:
                 self.coverage.save()
 
+            # Restore the old path
+            sys.path[0] = old_path0
+
     def do_debug(self, args):
         """Implementation of 'coverage debug'."""
 
         if not args:
             self.help_fn("What information would you like: data, sys?")
             return ERR
         for info in args:
             if info == 'sys':
                 print("-- sys ----------------------------------------")
-                for label, info in self.coverage.sysinfo():
-                    if info == []:
-                        info = "-none-"
-                    if isinstance(info, list):
-                        prefix = "%15s:" % label
-                        for e in info:
-                            print("%16s %s" % (prefix, e))
-                            prefix = ""
-                    else:
-                        print("%15s: %s" % (label, info))
+                for line in info_formatter(self.coverage.sysinfo()):
+                    print(" %s" % line)
             elif info == 'data':
                 print("-- data ---------------------------------------")
                 self.coverage.load()
                 print("path: %s" % self.coverage.data.filename)
                 print("has_arcs: %r" % self.coverage.data.has_arcs())
                 summary = self.coverage.data.summary(fullpath=True)
                 if summary:
                     filenames = sorted(summary.keys())
                     print("\n%d files:" % len(filenames))
                     for f in filenames:
@@ skipping 102 matching lines @@
 
 def main(argv=None):
     """The main entry point to Coverage.
 
     This is installed as the script entry point.
 
     """
     if argv is None:
         argv = sys.argv[1:]
     try:
+        start = time.clock()
         status = CoverageScript().command_line(argv)
+        end = time.clock()
+        if 0:
+            print("time: %.3fs" % (end - start))
     except ExceptionDuringRun:
         # An exception was caught while running the product code.  The
         # sys.exc_info() return tuple is packed into an ExceptionDuringRun
         # exception.
         _, err, _ = sys.exc_info()
         traceback.print_exception(*err.args)
         status = ERR
     except CoverageException:
         # A controlled error inside coverage.py: print the message to the user.
         _, err, _ = sys.exc_info()
         print(err)
         status = ERR
     except SystemExit:
         # The user called `sys.exit()`.  Exit with their argument, if any.
         _, err, _ = sys.exc_info()
         if err.args:
             status = err.args[0]
         else:
             status = None
     return status