eric: comparison DebugClients/Python/coverage/control.py

-:bedab77d0fa3
+:d6c795b5ce33
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
 # For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
 """Core control stuff for coverage.py."""
 import atexit
 import inspect
+import itertools
 import os
 import platform
 import re
 import sys
+import time
 import traceback
-from coverage import env, files
+from coverage import env
 from coverage.annotate import AnnotateReporter
 from coverage.backward import string_class, iitems
 from coverage.collector import Collector
-from coverage.config import CoverageConfig
+from coverage.config import read_coverage_config
 from coverage.data import CoverageData, CoverageDataFiles
-from coverage.debug import DebugControl
+from coverage.debug import DebugControl, write_formatted_info
 from coverage.files import TreeMatcher, FnmatchMatcher
 from coverage.files import PathAliases, find_python_files, prep_patterns
+from coverage.files import canonical_filename, set_relative_directory
 from coverage.files import ModuleMatcher, abs_file
 from coverage.html import HtmlReporter
 from coverage.misc import CoverageException, bool_or_none, join_regex
 from coverage.misc import file_be_gone, isolate_module
-from coverage.monkey import patch_multiprocessing
 from coverage.plugin import FileReporter
 from coverage.plugin_support import Plugins
-from coverage.python import PythonFileReporter
+from coverage.python import PythonFileReporter, source_for_file
 from coverage.results import Analysis, Numbers
 from coverage.summary import SummaryReporter
 from coverage.xmlreport import XmlReporter
+try:
+from coverage.multiproc import patch_multiprocessing
+except ImportError:                                         # pragma: only jython
+# Jython has no multiprocessing module.
+patch_multiprocessing = None
 os = isolate_module(os)
 # Pypy has some unusual stuff in the "stdlib".  Consider those locations
-# when deciding where the stdlib is.
+# when deciding where the stdlib is.  These modules are not used for anything,
-try:
+# they are modules importable from the pypy lib directories, so that we can
-import _structseq
+# find those directories.
-except ImportError:
+_structseq = _pypy_irc_topic = None
-_structseq = None
+if env.PYPY:
+try:
+import _structseq
+except ImportError:
+pass
+try:
+import _pypy_irc_topic
+except ImportError:
+pass
 class Coverage(object):
 """Programmatic access to coverage.py.
 * If it is a string, it is the name of the file to read.  If the
 file can't be read, it is an error.
 * If it is True, then a few standard files names are tried
-(".coveragerc", "setup.cfg").  It is not an error for these files
+(".coveragerc", "setup.cfg", "tox.ini").  It is not an error for
-to not be found.
+these files to not be found.
 * If it is False, then no configuration file is read.
 `source` is a list of file paths or package names.  Only code located
 in the trees indicated by the file paths or package names will be
 `debug` is a list of strings indicating what debugging information is
 desired.
 `concurrency` is a string indicating the concurrency library being used
 in the measured code.  Without this, coverage.py will get incorrect
-results.  Valid strings are "greenlet", "eventlet", "gevent",
+results if these libraries are in use.  Valid strings are "greenlet",
-"multiprocessing", or "thread" (the default).
+"eventlet", "gevent", "multiprocessing", or "thread" (the default).
+This can also be a list of these strings.
 .. versionadded:: 4.0
 The `concurrency` parameter.
-"""
+.. versionadded:: 4.2
-# Build our configuration from a number of sources:
+The `concurrency` parameter can now be a list of strings.
-# 1: defaults:
-self.config = CoverageConfig()
+"""
+# Build our configuration from a number of sources.
-# 2: from the rcfile, .coveragerc or setup.cfg file:
+self.config_file, self.config = read_coverage_config(
-if config_file:
+config_file=config_file,
-did_read_rc = False
-# Some API users were specifying ".coveragerc" to mean the same as
-# True, so make it so.
-if config_file == ".coveragerc":
-config_file = True
-specified_file = (config_file is not True)
-if not specified_file:
-config_file = ".coveragerc"
-did_read_rc = self.config.from_file(config_file)
-if not did_read_rc:
-if specified_file:
-raise CoverageException(
-"Couldn't read '%s' as a config file" % config_file
-)
-self.config.from_file("setup.cfg", section_prefix="coverage:")
-# 3: from environment variables:
-env_data_file = os.environ.get('COVERAGE_FILE')
-if env_data_file:
-self.config.data_file = env_data_file
-debugs = os.environ.get('COVERAGE_DEBUG')
-if debugs:
-self.config.debug.extend(debugs.split(","))
-# 4: from constructor arguments:
-self.config.from_args(
 data_file=data_file, cover_pylib=cover_pylib, timid=timid,
 branch=branch, parallel=bool_or_none(data_suffix),
-source=source, omit=omit, include=include, debug=debug,
+source=source, run_omit=omit, run_include=include, debug=debug,
+report_omit=omit, report_include=include,
 concurrency=concurrency,
 )
+# This is injectable by tests.
 self._debug_file = None
-self._auto_data = auto_data
+self._auto_load = self._auto_save = auto_data
 self._data_suffix = data_suffix
 # The matchers for _should_trace.
 self.source_match = None
 self.source_pkgs_match = None
 # A record of all the warnings that have been issued.
 self._warnings = []
 # Other instance attributes, set later.
 self.omit = self.include = self.source = None
+self.source_pkgs_unmatched = None
 self.source_pkgs = None
 self.data = self.data_files = self.collector = None
 self.plugins = None
-self.pylib_dirs = self.cover_dirs = None
+self.pylib_paths = self.cover_paths = None
 self.data_suffix = self.run_suffix = None
 self._exclude_re = None
 self.debug = None
 # State machine variables:
 # Have we initialized everything?
 self._inited = False
 # Have we started collecting and not stopped it?
 self._started = False
-# Have we measured some data and not harvested it?
-self._measured = False
+# If we have sub-process measurement happening automatically, then we
+# want any explicit creation of a Coverage object to mean, this process
+# is already coverage-aware, so don't auto-measure it.  By now, the
+# auto-creation of a Coverage object has already happened.  But we can
+# find it and tell it not to save its data.
+if not env.METACOV:
+_prevent_sub_process_measurement()
 def _init(self):
 """Set all the initial state.
 This is called by the public methods to initialize state. This lets us
 function is called.
 """
 if self._inited:
 return
+self._inited = True
 # Create and configure the debugging controller. COVERAGE_DEBUG_FILE
 # is an environment variable, the name of a file to append debug logs
 # to.
 if self._debug_file is None:
 self._debug_file = open(debug_file_name, "a")
 else:
 self._debug_file = sys.stderr
 self.debug = DebugControl(self.config.debug, self._debug_file)
+# _exclude_re is a dict that maps exclusion list names to compiled regexes.
+self._exclude_re = {}
+set_relative_directory()
 # Load plugins
 self.plugins = Plugins.load_plugins(self.config.plugins, self.config, self.debug)
-# _exclude_re is a dict that maps exclusion list names to compiled
+# Run configuring plugins.
-# regexes.
+for plugin in self.plugins.configurers:
-self._exclude_re = {}
+# We need an object with set_option and get_option. Either self or
-self._exclude_regex_stale()
+# self.config will do. Choosing randomly stops people from doing
+# other things with those objects, against the public API.  Yes,
-files.set_relative_directory()
+# this is a bit childish. :)
+plugin.configure([self, self.config][int(time.time()) % 2])
 # The source argument can be directories or package names.
 self.source = []
 self.source_pkgs = []
 for src in self.config.source or []:
-if os.path.exists(src):
+if os.path.isdir(src):
-self.source.append(files.canonical_filename(src))
+self.source.append(canonical_filename(src))
 else:
 self.source_pkgs.append(src)
+self.source_pkgs_unmatched = self.source_pkgs[:]
-self.omit = prep_patterns(self.config.omit)
-self.include = prep_patterns(self.config.include)
+self.omit = prep_patterns(self.config.run_omit)
+self.include = prep_patterns(self.config.run_include)
-concurrency = self.config.concurrency
-if concurrency == "multiprocessing":
+concurrency = self.config.concurrency or []
-patch_multiprocessing()
+if "multiprocessing" in concurrency:
-concurrency = None
+if not patch_multiprocessing:
+raise CoverageException(                    # pragma: only jython
+"multiprocessing is not supported on this Python"
+)
+patch_multiprocessing(rcfile=self.config_file)
+# Multi-processing uses parallel for the subprocesses, so also use
+# it for the main process.
+self.config.parallel = True
 self.collector = Collector(
 should_trace=self._should_trace,
 check_include=self._check_include_omit_etc,
 timid=self.config.timid,
 # Create the data file.  We do this at construction time so that the
 # data file will be written into the directory where the process
 # started rather than wherever the process eventually chdir'd to.
 self.data = CoverageData(debug=self.debug)
-self.data_files = CoverageDataFiles(basename=self.config.data_file, warn=self._warn)
+self.data_files = CoverageDataFiles(
+basename=self.config.data_file, warn=self._warn, debug=self.debug,
+)
 # The directories for files considered "installed with the interpreter".
-self.pylib_dirs = set()
+self.pylib_paths = set()
 if not self.config.cover_pylib:
 # Look at where some standard modules are located. That's the
 # indication for "installed with the interpreter". In some
 # environments (virtualenv, for example), these modules may be
 # spread across a few locations. Look at all the candidate modules
 # we've imported, and take all the different ones.
-for m in (atexit, inspect, os, platform, re, _structseq, traceback):
+for m in (atexit, inspect, os, platform, _pypy_irc_topic, re, _structseq, traceback):
 if m is not None and hasattr(m, "__file__"):
-self.pylib_dirs.add(self._canonical_dir(m))
+self.pylib_paths.add(self._canonical_path(m, directory=True))
 if _structseq and not hasattr(_structseq, '__file__'):
 # PyPy 2.4 has no __file__ in the builtin modules, but the code
 # objects still have the file names.  So dig into one to find
 # the path to exclude.
 structseq_new = _structseq.structseq_new
 try:
 structseq_file = structseq_new.func_code.co_filename
 except AttributeError:
 structseq_file = structseq_new.__code__.co_filename
-self.pylib_dirs.add(self._canonical_dir(structseq_file))
+self.pylib_paths.add(self._canonical_path(structseq_file))
 # To avoid tracing the coverage.py code itself, we skip anything
 # located where we are.
-self.cover_dirs = [self._canonical_dir(__file__)]
+self.cover_paths = [self._canonical_path(__file__, directory=True)]
 if env.TESTING:
+# Don't include our own test code.
+self.cover_paths.append(os.path.join(self.cover_paths[0], "tests"))
 # When testing, we use PyContracts, which should be considered
 # part of coverage.py, and it uses six. Exclude those directories
 # just as we exclude ourselves.
-import contracts, six
+import contracts
+import six
 for mod in [contracts, six]:
-self.cover_dirs.append(self._canonical_dir(mod))
+self.cover_paths.append(self._canonical_path(mod))
 # Set the reporting precision.
 Numbers.set_precision(self.config.precision)
 atexit.register(self._atexit)
-self._inited = True
 # Create the matchers we need for _should_trace
 if self.source or self.source_pkgs:
 self.source_match = TreeMatcher(self.source)
 self.source_pkgs_match = ModuleMatcher(self.source_pkgs)
 else:
-if self.cover_dirs:
+if self.cover_paths:
-self.cover_match = TreeMatcher(self.cover_dirs)
+self.cover_match = TreeMatcher(self.cover_paths)
-if self.pylib_dirs:
+if self.pylib_paths:
-self.pylib_match = TreeMatcher(self.pylib_dirs)
+self.pylib_match = TreeMatcher(self.pylib_paths)
 if self.include:
 self.include_match = FnmatchMatcher(self.include)
 if self.omit:
 self.omit_match = FnmatchMatcher(self.omit)
 # The user may want to debug things, show info if desired.
+self._write_startup_debug()
+def _write_startup_debug(self):
+"""Write out debug info at startup if needed."""
 wrote_any = False
-if self.debug.should('config'):
+with self.debug.without_callers():
-config_info = sorted(self.config.__dict__.items())
+if self.debug.should('config'):
-self.debug.write_formatted_info("config", config_info)
+config_info = sorted(self.config.__dict__.items())
-wrote_any = True
+write_formatted_info(self.debug, "config", config_info)
+wrote_any = True
-if self.debug.should('sys'):
-self.debug.write_formatted_info("sys", self.sys_info())
+if self.debug.should('sys'):
-for plugin in self.plugins:
+write_formatted_info(self.debug, "sys", self.sys_info())
-header = "sys: " + plugin._coverage_plugin_name
+for plugin in self.plugins:
-info = plugin.sys_info()
+header = "sys: " + plugin._coverage_plugin_name
-self.debug.write_formatted_info(header, info)
+info = plugin.sys_info()
-wrote_any = True
+write_formatted_info(self.debug, header, info)
+wrote_any = True
 if wrote_any:
-self.debug.write_formatted_info("end", ())
+write_formatted_info(self.debug, "end", ())
-def _canonical_dir(self, morf):
+def _canonical_path(self, morf, directory=False):
-"""Return the canonical directory of the module or file `morf`."""
+"""Return the canonical path of the module or file `morf`.
-morf_filename = PythonFileReporter(morf, self).filename
-return os.path.split(morf_filename)[0]
+If the module is a package, then return its directory. If it is a
+module, then return its file, unless `directory` is True, in which
-def _source_for_file(self, filename):
+case return its enclosing directory.
-"""Return the source file for `filename`.
+"""
-Given a file name being traced, return the best guess as to the source
+morf_path = PythonFileReporter(morf, self).filename
-file to attribute it to.
+if morf_path.endswith("__init__.py") or directory:
+morf_path = os.path.split(morf_path)[0]
-"""
+return morf_path
-if filename.endswith(".py"):
-# .py files are themselves source files.
-return filename
-elif filename.endswith((".pyc", ".pyo")):
-# Bytecode files probably have source files near them.
-py_filename = filename[:-1]
-if os.path.exists(py_filename):
-# Found a .py file, use that.
-return py_filename
-if env.WINDOWS:
-# On Windows, it could be a .pyw file.
-pyw_filename = py_filename + "w"
-if os.path.exists(pyw_filename):
-return pyw_filename
-# Didn't find source, but it's probably the .py file we want.
-return py_filename
-elif filename.endswith("$py.class"):
-# Jython is easy to guess.
-return filename[:-9] + ".py"
-# No idea, just use the file name as-is.
-return filename
 def _name_for_module(self, module_globals, filename):
 """Get the name of the module for a set of globals and file name.
 For configurability's sake, we allow __main__ modules to be matched by
 full dotted module name, otherwise, we resort to interpreting the
 file name to get the module's name.  In the case that the module name
 can't be determined, None is returned.
 """
+if module_globals is None:          # pragma: only ironpython
+# IronPython doesn't provide globals: https://github.com/IronLanguages/main/issues/1296
+module_globals = {}
 dunder_name = module_globals.get('__name__', None)
 if isinstance(dunder_name, str) and dunder_name != '__main__':
 # This is the usual case: an imported module.
 return dunder_name
 # the file name at the time the .pyc was compiled.  The second name is
 # __file__, which is where the .pyc was actually loaded from.  Since
 # .pyc files can be moved after compilation (for example, by being
 # installed), we look for __file__ in the frame and prefer it to the
 # co_filename value.
-dunder_file = frame.f_globals.get('__file__')
+dunder_file = frame.f_globals and frame.f_globals.get('__file__')
 if dunder_file:
-filename = self._source_for_file(dunder_file)
+filename = source_for_file(dunder_file)
 if original_filename and not original_filename.startswith('<'):
 orig = os.path.basename(original_filename)
 if orig != os.path.basename(filename):
 # Files shouldn't be renamed when moved. This happens when
 # exec'ing code.  If it seems like something is wrong with
 # Jython reports the .class file to the tracer, use the source file.
 if filename.endswith("$py.class"):
 filename = filename[:-9] + ".py"
-canonical = files.canonical_filename(filename)
+canonical = canonical_filename(filename)
 disp.canonical_filename = canonical
 # Try the plugins, see if they have an opinion about the file.
 plugin = None
 for plugin in self.plugins.file_tracers:
 disp.trace = True
 disp.file_tracer = file_tracer
 if file_tracer.has_dynamic_source_filename():
 disp.has_dynamic_filename = True
 else:
-disp.source_filename = files.canonical_filename(
+disp.source_filename = canonical_filename(
 file_tracer.source_filename()
 )
 break
 except Exception:
 self._warn(
-"Disabling plugin %r due to an exception:" % (
+"Disabling plug-in %r due to an exception:" % (
 plugin._coverage_plugin_name
 )
 )
 traceback.print_exc()
 plugin._coverage_enabled = False
 # about the outer bound of what to measure and we don't have to apply
 # any canned exclusions. If they didn't, then we have to exclude the
 # stdlib and coverage.py directories.
 if self.source_match:
 if self.source_pkgs_match.match(modulename):
-if modulename in self.source_pkgs:
+if modulename in self.source_pkgs_unmatched:
-self.source_pkgs.remove(modulename)
+self.source_pkgs_unmatched.remove(modulename)
-return None  # There's no reason to skip this file.
+elif not self.source_match.match(filename):
-if not self.source_match.match(filename):
 return "falls outside the --source trees"
 elif self.include_match:
 if not self.include_match.match(filename):
 return "falls outside the --include trees"
 else:
 msg = "Not including %r: %s" % (filename, reason)
 self.debug.write(msg)
 return not reason
-def _warn(self, msg):
+def _warn(self, msg, slug=None):
-"""Use `msg` as a warning."""
+"""Use `msg` as a warning.
+For warning suppression, use `slug` as the shorthand.
+"""
+if slug in self.config.disable_warnings:
+# Don't issue the warning
+return
 self._warnings.append(msg)
+if slug:
+msg = "%s (%s)" % (msg, slug)
 if self.debug.should('pid'):
 msg = "[%d] %s" % (os.getpid(), msg)
 sys.stderr.write("Coverage.py warning: %s\n" % msg)
 def get_option(self, option_name):
 `option_name` is a colon-separated string indicating the section and
 option name.  For example, the ``branch`` option in the ``[run]``
 section of the config file would be indicated with ``"run:branch"``.
-`value` is the new value for the option.  This should be a Python
+`value` is the new value for the option.  This should be an
-value where appropriate.  For example, use True for booleans, not the
+appropriate Python value.  For example, use True for booleans, not the
 string ``"True"``.
 As an example, calling::
 cov.set_option("run:branch", True)
 self.data_files.read(self.data)
 def start(self):
 """Start measuring code coverage.
-Coverage measurement actually occurs in functions called after
+Coverage measurement only occurs in functions called after
 :meth:`start` is invoked.  Statements in the same scope as
 :meth:`start` won't be measured.
 Once you invoke :meth:`start`, you must also call :meth:`stop`
 eventually, or your process might not shut down cleanly.
 """
 self._init()
+if self.include:
+if self.source or self.source_pkgs:
+self._warn("--include is ignored because --source is set", slug="include-ignored")
 if self.run_suffix:
 # Calling start() means we're running code, so use the run_suffix
 # as the data_suffix when we eventually save the data.
 self.data_suffix = self.run_suffix
-if self._auto_data:
+if self._auto_load:
 self.load()
 self.collector.start()
 self._started = True
-self._measured = True
 def stop(self):
 """Stop measuring code coverage."""
 if self._started:
 self.collector.stop()
 self._started = False
 def _atexit(self):
 """Clean up on process shutdown."""
+if self.debug.should("process"):
+self.debug.write("atexit: {0!r}".format(self))
 if self._started:
 self.stop()
-if self._auto_data:
+if self._auto_save:
 self.save()
 def erase(self):
 """Erase previously-collected coverage data.
 """Save the collected coverage data to the data file."""
 self._init()
 self.get_data()
 self.data_files.write(self.data, suffix=self.data_suffix)
-def combine(self, data_paths=None):
+def combine(self, data_paths=None, strict=False):
 """Combine together a number of similarly-named coverage data files.
 All coverage data files whose name starts with `data_file` (from the
 coverage() constructor) will be read, and combined together into the
 current measurements.
 `data_paths` is a list of files or directories from which data should
 be combined. If no list is passed, then the data files from the
 directory indicated by the current data file (probably the current
 directory) will be combined.
+If `strict` is true, then it is an error to attempt to combine when
+there are no data files to combine.
 .. versionadded:: 4.0
 The `data_paths` parameter.
+.. versionadded:: 4.3
+The `strict` parameter.
 """
 self._init()
 self.get_data()
 for paths in self.config.paths.values():
 result = paths[0]
 for pattern in paths[1:]:
 aliases.add(pattern, result)
-self.data_files.combine_parallel_data(self.data, aliases=aliases, data_paths=data_paths)
+self.data_files.combine_parallel_data(
+self.data, aliases=aliases, data_paths=data_paths, strict=strict,
+)
 def get_data(self):
-"""Get the collected data and reset the collector.
+"""Get the collected data.
 Also warn about various problems collecting data.
 Returns a :class:`coverage.CoverageData`, the collected coverage data.
 .. versionadded:: 4.0
 """
 self._init()
-if not self._measured:
-return self.data
+if self.collector.save_data(self.data):
+self._post_save_work()
-self.collector.save_data(self.data)
+return self.data
-# If there are still entries in the source_pkgs list, then we never
-# encountered those packages.
+def _post_save_work(self):
+"""After saving data, look for warnings, post-work, etc.
+Warn about things that should have happened but didn't.
+Look for unexecuted files.
+"""
+# If there are still entries in the source_pkgs_unmatched list,
+# then we never encountered those packages.
 if self._warn_unimported_source:
-for pkg in self.source_pkgs:
+for pkg in self.source_pkgs_unmatched:
-if pkg not in sys.modules:
+self._warn_about_unmeasured_code(pkg)
-self._warn("Module %s was never imported." % pkg)
-elif not (
-hasattr(sys.modules[pkg], '__file__') and
-os.path.exists(sys.modules[pkg].__file__)
-):
-self._warn("Module %s has no Python source." % pkg)
-else:
-self._warn("Module %s was previously imported, but not measured." % pkg)
 # Find out if we got any data.
 if not self.data and self._warn_no_data:
-self._warn("No data was collected.")
+self._warn("No data was collected.", slug="no-data-collected")
 # Find files that were never executed at all.
+for pkg in self.source_pkgs:
+if (not pkg in sys.modules or
+not hasattr(sys.modules[pkg], '__file__') or
+not os.path.exists(sys.modules[pkg].__file__)):
+continue
+pkg_file = source_for_file(sys.modules[pkg].__file__)
+self._find_unexecuted_files(self._canonical_path(pkg_file))
 for src in self.source:
-for py_file in find_python_files(src):
+self._find_unexecuted_files(src)
-py_file = files.canonical_filename(py_file)
-if self.omit_match and self.omit_match.match(py_file):
-# Turns out this file was omitted, so don't pull it back
-# in as unexecuted.
-continue
-self.data.touch_file(py_file)
 if self.config.note:
 self.data.add_run_info(note=self.config.note)
-self._measured = False
+def _warn_about_unmeasured_code(self, pkg):
-return self.data
+"""Warn about a package or module that we never traced.
+`pkg` is a string, the name of the package or module.
+"""
+mod = sys.modules.get(pkg)
+if mod is None:
+self._warn("Module %s was never imported." % pkg, slug="module-not-imported")
+return
+is_namespace = hasattr(mod, '__path__') and not hasattr(mod, '__file__')
+has_file = hasattr(mod, '__file__') and os.path.exists(mod.__file__)
+if is_namespace:
+# A namespace package. It's OK for this not to have been traced,
+# since there is no code directly in it.
+return
+if not has_file:
+self._warn("Module %s has no Python source." % pkg, slug="module-not-python")
+return
+# The module was in sys.modules, and seems like a module with code, but
+# we never measured it. I guess that means it was imported before
+# coverage even started.
+self._warn(
+"Module %s was previously imported, but not measured" % pkg,
+slug="module-not-measured",
+)
+def _find_plugin_files(self, src_dir):
+"""Get executable files from the plugins."""
+for plugin in self.plugins.file_tracers:
+for x_file in plugin.find_executable_files(src_dir):
+yield x_file, plugin._coverage_plugin_name
+def _find_unexecuted_files(self, src_dir):
+"""Find unexecuted files in `src_dir`.
+Search for files in `src_dir` that are probably importable,
+and add them as unexecuted files in `self.data`.
+"""
+py_files = ((py_file, None) for py_file in find_python_files(src_dir))
+plugin_files = self._find_plugin_files(src_dir)
+for file_path, plugin_name in itertools.chain(py_files, plugin_files):
+file_path = canonical_filename(file_path)
+if self.omit_match and self.omit_match.match(file_path):
+# Turns out this file was omitted, so don't pull it back
+# in as unexecuted.
+continue
+self.data.touch_file(file_path, plugin_name)
 # Backward compatibility with version 1.
 def analysis(self, morf):
 """Like `analysis2` but doesn't return excluded line numbers."""
 f, s, _, m, mf = self.analysis2(morf)
 `include` is a list of file name patterns.  Files that match will be
 included in the report. Files matching `omit` will not be included in
 the report.
+If `skip_covered` is True, don't report on files with 100% coverage.
 Returns a float, the total percentage covered.
 """
 self.get_data()
 self.config.from_args(
-ignore_errors=ignore_errors, omit=omit, include=include,
+ignore_errors=ignore_errors, report_omit=omit, report_include=include,
 show_missing=show_missing, skip_covered=skip_covered,
 )
 reporter = SummaryReporter(self, self.config)
 return reporter.report(morfs, outfile=file)
 See :meth:`report` for other arguments.
 """
 self.get_data()
 self.config.from_args(
-ignore_errors=ignore_errors, omit=omit, include=include
+ignore_errors=ignore_errors, report_omit=omit, report_include=include
 )
 reporter = AnnotateReporter(self, self.config)
 reporter.report(morfs, directory=directory)
 def html_report(self, morfs=None, directory=None, ignore_errors=None,
-omit=None, include=None, extra_css=None, title=None):
+omit=None, include=None, extra_css=None, title=None,
+skip_covered=None):
 """Generate an HTML report.
 The HTML is written to `directory`.  The file "index.html" is the
 overview starting point, with links to more detailed pages for
 individual modules.
 Returns a float, the total percentage covered.
 """
 self.get_data()
 self.config.from_args(
-ignore_errors=ignore_errors, omit=omit, include=include,
+ignore_errors=ignore_errors, report_omit=omit, report_include=include,
 html_dir=directory, extra_css=extra_css, html_title=title,
+skip_covered=skip_covered,
 )
 reporter = HtmlReporter(self, self.config)
 return reporter.report(morfs)
 def xml_report(
 Returns a float, the total percentage covered.
 """
 self.get_data()
 self.config.from_args(
-ignore_errors=ignore_errors, omit=omit, include=include,
+ignore_errors=ignore_errors, report_omit=omit, report_include=include,
 xml_output=outfile,
 )
 file_to_close = None
 delete_file = False
 if self.config.xml_output:
 import coverage as covmod
 self._init()
-ft_plugins = []
+def plugin_info(plugins):
-for ft in self.plugins.file_tracers:
+"""Make an entry for the sys_info from a list of plug-ins."""
-ft_name = ft._coverage_plugin_name
+entries = []
-if not ft._coverage_enabled:
+for plugin in plugins:
-ft_name += " (disabled)"
+entry = plugin._coverage_plugin_name
-ft_plugins.append(ft_name)
+if not plugin._coverage_enabled:
+entry += " (disabled)"
+entries.append(entry)
+return entries
 info = [
 ('version', covmod.__version__),
 ('coverage', covmod.__file__),
-('cover_dirs', self.cover_dirs),
+('cover_paths', self.cover_paths),
-('pylib_dirs', self.pylib_dirs),
+('pylib_paths', self.pylib_paths),
 ('tracer', self.collector.tracer_name()),
-('plugins.file_tracers', ft_plugins),
+('plugins.file_tracers', plugin_info(self.plugins.file_tracers)),
+('plugins.configurers', plugin_info(self.plugins.configurers)),
 ('config_files', self.config.attempted_config_files),
 ('configs_read', self.config.config_files),
 ('data_path', self.data_files.filename),
 ('python', sys.version.replace('\n', '')),
 ('platform', platform.platform()),
 # already been started, so we can avoid doing it twice.
 #
 # https://bitbucket.org/ned/coveragepy/issue/340/keyerror-subpy has more
 # details.
-if hasattr(process_startup, "done"):
+if hasattr(process_startup, "coverage"):
 # We've annotated this function before, so we must have already
 # started coverage.py in this process.  Nothing to do.
 return None
-process_startup.done = True
+cov = Coverage(config_file=cps)
-cov = Coverage(config_file=cps, auto_data=True)
+process_startup.coverage = cov
 cov.start()
 cov._warn_no_data = False
 cov._warn_unimported_source = False
+cov._auto_save = True
 return cov
+def _prevent_sub_process_measurement():
+"""Stop any subprocess auto-measurement from writing data."""
+auto_created_coverage = getattr(process_startup, "coverage", None)
+if auto_created_coverage is not None:
+auto_created_coverage._auto_save = False

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/control.py

DebugClients/Python/coverage/control.py