Coverage API

The API to coverage.py is very simple, contained in a single module called coverage. Most of the interface is in a single class, called Coverage. Methods on the Coverage object correspond roughly to operations available in the command line interface. For example, a simple use would be:

import coverage

cov = coverage.Coverage()
cov.start()

# .. call your code ..

cov.stop()
cov.save()

cov.html_report()

The coverage module

class coverage.Coverage(data_file=None, data_suffix=None, cover_pylib=None, auto_data=False, timid=None, branch=None, config_file=True, source=None, omit=None, include=None, debug=None, concurrency=None)

Programmatic access to coverage.py.

To use:

from coverage import Coverage

cov = Coverage()
cov.start()
#.. call your code ..
cov.stop()
cov.html_report(directory='covhtml')

data_file is the base name of the data file to use, defaulting to ”.coverage”. data_suffix is appended (with a dot) to data_file to create the final file name. If data_suffix is simply True, then a suffix is created with the machine and process identity included.

cover_pylib is a boolean determining whether Python code installed with the Python interpreter is measured. This includes the Python standard library and any packages installed with the interpreter.

If auto_data is true, then any existing data file will be read when coverage measurement starts, and data will be saved automatically when measurement stops.

If timid is true, then a slower and simpler trace function will be used. This is important for some environments where manipulation of tracing functions breaks the faster trace function.

If branch is true, then branch coverage will be measured in addition to the usual statement coverage.

config_file determines what configuration file to read:

  • If it is ”.coveragerc”, it is interpreted as if it were True, for backward compatibility.
  • 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 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 measured.

include and omit are lists of filename patterns. Files that match include will be measured, files that match omit will not. Each will also accept a single string argument.

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”, or “thread” (the default).

analysis(morf)

Like analysis2 but doesn’t return excluded line numbers.

analysis2(morf)

Analyze a module.

morf is a module or a filename. It will be analyzed to determine its coverage statistics. The return value is a 5-tuple:

  • The filename for the module.
  • A list of line numbers of executable statements.
  • A list of line numbers of excluded statements.
  • A list of line numbers of statements not run (missing from execution).
  • A readable formatted string of the missing line numbers.

The analysis uses the source file itself and the current measured coverage data.

annotate(morfs=None, directory=None, ignore_errors=None, omit=None, include=None)

Annotate a list of modules.

Each module in morfs is annotated. The source is written to a new file, named with a ”,cover” suffix, with each line prefixed with a marker to indicate the coverage of the line. Covered lines have “>”, excluded lines have “-”, and missing lines have ”!”.

See coverage.report() for other arguments.

clear_exclude(which='exclude')

Clear the exclude list.

combine()

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.

erase()

Erase previously-collected coverage data.

This removes the in-memory data collected in this session as well as discarding the data file.

exclude(regex, which='exclude')

Exclude source lines from execution consideration.

A number of lists of regular expressions are maintained. Each list selects lines that are treated differently during reporting.

which determines which list is modified. The “exclude” list selects lines that are not considered executable at all. The “partial” list indicates lines with branches that are not taken.

regex is a regular expression. The regex is added to the specified list. If any of the regexes in the list is found in a line, the line is marked for special treatment during reporting.

get_exclude_list(which='exclude')

Return a list of excluded regex patterns.

which indicates which list is desired. See exclude for the lists that are available, and their meaning.

html_report(morfs=None, directory=None, ignore_errors=None, omit=None, include=None, extra_css=None, title=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.

extra_css is a path to a file of other CSS to apply on the page. It will be copied into the HTML directory.

title is a text string (not HTML) to use as the title of the HTML report.

See coverage.report() for other arguments.

Returns a float, the total percentage covered.

load()

Load previously-collected coverage data from the data file.

report(morfs=None, show_missing=True, ignore_errors=None, file=None, omit=None, include=None, skip_covered=False)

Write a summary report to file.

Each module in morfs is listed, with counts of statements, executed statements, missing statements, and a list of lines missed.

include is a list of filename patterns. Modules whose filenames match those patterns will be included in the report. Modules matching omit will not be included in the report.

Returns a float, the total percentage covered.

save()

Save the collected coverage data to the data file.

start()

Start measuring code coverage.

Coverage measurement actually occurs in functions called after start is invoked. Statements in the same scope as start won’t be measured.

Once you invoke start, you must also call stop eventually, or your process might not shut down cleanly.

stop()

Stop measuring code coverage.

sys_info()

Return a list of (key, value) pairs showing internal information.

use_cache(usecache)

Control the use of a data file (incorrectly called a cache).

usecache is true or false, whether to read and write data on disk.

xml_report(morfs=None, outfile=None, ignore_errors=None, omit=None, include=None)

Generate an XML report of coverage results.

The report is compatible with Cobertura reports.

Each module in morfs is included in the report. outfile is the path to write the file to, “-” will write to stdout.

See coverage.report() for other arguments.

Returns a float, the total percentage covered.

Starting coverage automatically

This function is used to start coverage measurement automatically when Python starts. See Measuring sub-processes for details.

coverage.process_startup()

Call this at Python start-up to perhaps measure coverage.

If the environment variable COVERAGE_PROCESS_START is defined, coverage measurement is started. The value of the variable is the config file to use.

There are two ways to configure your Python installation to invoke this function when Python starts:

  1. Create or append to sitecustomize.py to add these lines:

    import coverage
    coverage.process_startup()
    
  2. Create a .pth file in your Python installation containing:

    import coverage; coverage.process_startup()