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

third_party/coverage-3.7.1/coverage/data.py

 """Coverage data for Coverage."""
 
 import os
 
 from coverage.backward import iitems, pickle, sorted    # pylint: disable=W0622
 from coverage.files import PathAliases
 from coverage.misc import file_be_gone
 
 
 class CoverageData(object):
     """Manages collected coverage data, including file storage.
 
     The data file format is a pickled dict, with these keys:
 
         * collector: a string identifying the collecting software
 
         * lines: a dict mapping filenames to sorted lists of line numbers
           executed:
             { 'file1': [17,23,45],  'file2': [1,2,3], ... }
 
         * arcs: a dict mapping filenames to sorted lists of line number pairs:
             { 'file1': [(17,23), (17,25), (25,26)], ... }
 
     """
 
-    def __init__(self, basename=None, collector=None):
+    def __init__(self, basename=None, collector=None, debug=None):
         """Create a CoverageData.
 
         `basename` is the name of the file to use for storing data.
 
         `collector` is a string describing the coverage measurement software.
 
+        `debug` is a `DebugControl` object for writing debug messages.
+
         """
         self.collector = collector or 'unknown'
+        self.debug = debug
 
         self.use_file = True
 
         # Construct the filename that will be used for data file storage, if we
         # ever do any file storage.
         self.filename = basename or ".coverage"
         self.filename = os.path.abspath(self.filename)
 
         # A map from canonical Python source file name to a dictionary in
         # which there's an entry for each line number that has been
@@ skipping 69 matching lines @@
         data = {}
 
         data['lines'] = self.line_data()
         arcs = self.arc_data()
         if arcs:
             data['arcs'] = arcs
 
         if self.collector:
             data['collector'] = self.collector
 
+        if self.debug and self.debug.should('dataio'):
+            self.debug.write("Writing data to %r" % (filename,))
+
         # Write the pickle to the file.
         fdata = open(filename, 'wb')
         try:
             pickle.dump(data, fdata, 2)
         finally:
             fdata.close()
 
     def read_file(self, filename):
         """Read the coverage data from `filename`."""
         self.lines, self.arcs = self._read_file(filename)
 
     def raw_data(self, filename):
         """Return the raw pickled data from `filename`."""
+        if self.debug and self.debug.should('dataio'):
+            self.debug.write("Reading data from %r" % (filename,))
         fdata = open(filename, 'rb')
         try:
             data = pickle.load(fdata)
         finally:
             fdata.close()
         return data
 
     def _read_file(self, filename):
         """Return the stored coverage data from the given file.
 
@@ skipping 114 matching lines @@
 
 if __name__ == '__main__':
     # Ad-hoc: show the raw data in a data file.
     import pprint, sys
     covdata = CoverageData()
     if sys.argv[1:]:
         fname = sys.argv[1]
     else:
         fname = covdata.filename
     pprint.pprint(covdata.raw_data(fname))