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

third_party/coverage-3.7.1/coverage/collector.py

 """Raw data collector for Coverage."""
 
 import os, sys, threading
 
 try:
     # Use the C extension code when we can, for speed.
     from coverage.tracer import CTracer         # pylint: disable=F0401,E0611
 except ImportError:
     # Couldn't import the C extension, maybe it isn't built.
     if os.getenv('COVERAGE_TEST_TRACER') == 'c':
@@ skipping 33 matching lines @@
         self.data = None
         self.should_trace = None
         self.should_trace_cache = None
         self.warn = None
         self.cur_file_data = None
         self.last_line = 0
         self.data_stack = []
         self.last_exc_back = None
         self.last_exc_firstlineno = 0
         self.arcs = False
+        self.thread = None
+        self.stopped = False
 
     def _trace(self, frame, event, arg_unused):
         """The trace function passed to sys.settrace."""
 
-        #print("trace event: %s %r @%d" % (
-        #           event, frame.f_code.co_filename, frame.f_lineno),
-        #      file=sys.stderr)
+        if self.stopped:
+            return
+
+        if 0:
+            sys.stderr.write("trace event: %s %r @%d\n" % (
+                event, frame.f_code.co_filename, frame.f_lineno
+            ))
 
         if self.last_exc_back:
             if frame == self.last_exc_back:
                 # Someone forgot a return event.
                 if self.arcs and self.cur_file_data:
                     pair = (self.last_line, -self.last_exc_firstlineno)
                     self.cur_file_data[pair] = None
                 self.cur_file_data, self.last_line = self.data_stack.pop()
             self.last_exc_back = None
 
         if event == 'call':
             # Entering a new function context.  Decide if we should trace
             # in this file.
             self.data_stack.append((self.cur_file_data, self.last_line))
             filename = frame.f_code.co_filename
-            tracename = self.should_trace_cache.get(filename)
-            if tracename is None:
+            if filename not in self.should_trace_cache:
                 tracename = self.should_trace(filename, frame)
                 self.should_trace_cache[filename] = tracename
+            else:
+                tracename = self.should_trace_cache[filename]
             #print("called, stack is %d deep, tracename is %r" % (
             #               len(self.data_stack), tracename))
             if tracename:
                 if tracename not in self.data:
                     self.data[tracename] = {}
                 self.cur_file_data = self.data[tracename]
             else:
                 self.cur_file_data = None
             # Set the last_line to -1 because the next arc will be entering a
             # code block, indicated by (-1, n).
@@ skipping 20 matching lines @@
             self.last_exc_back = frame.f_back
             self.last_exc_firstlineno = frame.f_code.co_firstlineno
         return self._trace
 
     def start(self):
         """Start this Tracer.
 
         Return a Python function suitable for use with sys.settrace().
 
         """
+        self.thread = threading.currentThread()
         sys.settrace(self._trace)
         return self._trace
 
     def stop(self):
         """Stop this Tracer."""
+        self.stopped = True
+        if self.thread != threading.currentThread():
+            # Called on a different thread than started us: we can't unhook
+            # ourseves, but we've set the flag that we should stop, so we won't
+            # do any more tracing.
+            return
+
         if hasattr(sys, "gettrace") and self.warn:
             if sys.gettrace() != self._trace:
                 msg = "Trace function changed, measurement is likely wrong: %r"
                 self.warn(msg % (sys.gettrace(),))
-                #--debug
-                #from coverage.misc import short_stack
-                #self.warn(msg % (sys.gettrace()))#, short_stack()))
+        #print("Stopping tracer on %s" % threading.current_thread().ident)
         sys.settrace(None)
 
     def get_stats(self):
         """Return a dictionary of statistics, or None."""
         return None
 
 
 class Collector(object):
     """Collects trace data.
 
@@ skipping 12 matching lines @@
 
     # The stack of active Collectors.  Collectors are added here when started,
     # and popped when stopped.  Collectors on the stack are paused when not
     # the top, and resumed when they become the top again.
     _collectors = []
 
     def __init__(self, should_trace, timid, branch, warn):
         """Create a collector.
 
         `should_trace` is a function, taking a filename, and returning a
-        canonicalized filename, or False depending on whether the file should
+        canonicalized filename, or None depending on whether the file should
         be traced or not.
 
         If `timid` is true, then a slower simpler trace function will be
         used.  This is important for some environments where manipulation of
         tracing functions make the faster more sophisticated trace function not
         operate properly.
 
         If `branch` is true, then branches will be measured.  This involves
         collecting data on which statements followed each other (arcs).  Use
         `get_arc_data` to get the arc data.
@@ skipping 23 matching lines @@
         return self._trace_class.__name__
 
     def reset(self):
         """Clear collected data, and prepare to collect more."""
         # A dictionary mapping filenames to dicts with linenumber keys,
         # or mapping filenames to dicts with linenumber pairs as keys.
         self.data = {}
 
         # A cache of the results from should_trace, the decision about whether
         # to trace execution in a file. A dict of filename to (filename or
-        # False).
+        # None).
         self.should_trace_cache = {}
 
         # Our active Tracers.
         self.tracers = []
 
     def _start_tracer(self):
         """Start a new Tracer object, and store it in self.tracers."""
         tracer = self._trace_class()
         tracer.data = self.data
         tracer.arcs = self.branch
@@ skipping 112 matching lines @@
         Data is { filename: { (l1, l2): None, ...}, ...}
 
         Note that no data is collected or returned if the Collector wasn't
         created with `branch` true.
 
         """
         if self.branch:
             return self.data
         else:
             return {}