Coverage for coverage/__init__.py : + 100.000% +
+
+
+
+
+
+
+ 
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Code coverage measurement for Python.
+ +6Ned Batchelder
+7https://nedbatchelder.com/code/coverage
+ +9"""
+ +11import sys
+ +13from coverage.version import __version__, __url__, version_info
+ +15from coverage.control import Coverage, process_startup
+16from coverage.data import CoverageData
+17from coverage.misc import CoverageException
+18from coverage.plugin import CoveragePlugin, FileTracer, FileReporter
+19from coverage.pytracer import PyTracer
+ +21# Backward compatibility.
+22coverage = Coverage
+ +24# On Windows, we encode and decode deep enough that something goes wrong and
+25# the encodings.utf_8 module is loaded and then unloaded, I don't know why.
+26# Adding a reference here prevents it from being unloaded. Yuk.
+27import encodings.utf_8 # pylint: disable=wrong-import-position, wrong-import-order
+ +29# Because of the "from coverage.control import fooey" lines at the top of the
+30# file, there's an entry for coverage.coverage in sys.modules, mapped to None.
+31# This makes some inspection tools (like pydoc) unable to find the class
+32# coverage.coverage. So remove that entry.
+33try:
+34 del sys.modules['coverage.coverage']
+35except KeyError:
+36 pass
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Coverage.py's main entry point."""
+ +6import sys
+7from coverage.cmdline import main
+8sys.exit(main())
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Source file annotation for coverage.py."""
+ +6import io
+7import os
+8import re
+ +10from coverage.files import flat_rootname
+11from coverage.misc import ensure_dir, isolate_module
+12from coverage.report import get_analysis_to_report
+ +14os = isolate_module(os)
+ + +17class AnnotateReporter(object):
+18 """Generate annotated source files showing line coverage.
+ +20 This reporter creates annotated copies of the measured source files. Each
+21 .py file is copied as a .py,cover file, with a left-hand margin annotating
+22 each line::
+ +24 > def h(x):
+25 - if 0: #pragma: no cover
+26 - pass
+27 > if x == 1:
+28 ! a = 1
+29 > else:
+30 > a = 2
+ +32 > h(2)
+ +34 Executed lines use '>', lines not executed use '!', lines excluded from
+35 consideration use '-'.
+ +37 """
+ +39 def __init__(self, coverage):
+40 self.coverage = coverage
+41 self.config = self.coverage.config
+42 self.directory = None
+ +44 blank_re = re.compile(r"\s*(#|$)")
+45 else_re = re.compile(r"\s*else\s*:\s*(#|$)")
+ +47 def report(self, morfs, directory=None):
+48 """Run the report.
+ +50 See `coverage.report()` for arguments.
+ +52 """
+53 self.directory = directory
+54 self.coverage.get_data()
+55 for fr, analysis in get_analysis_to_report(self.coverage, morfs):
+56 self.annotate_file(fr, analysis)
+ +58 def annotate_file(self, fr, analysis):
+59 """Annotate a single file.
+ +61 `fr` is the FileReporter for the file to annotate.
+ +63 """
+64 statements = sorted(analysis.statements)
+65 missing = sorted(analysis.missing)
+66 excluded = sorted(analysis.excluded)
+ +68 if self.directory:
+69 ensure_dir(self.directory)
+70 dest_file = os.path.join(self.directory, flat_rootname(fr.relative_filename()))
+71 if dest_file.endswith("_py"): 71 ↛ 73line 71 didn't jump to line 73, because the condition on line 71 was never false
+72 dest_file = dest_file[:-3] + ".py"
+73 dest_file += ",cover"
+74 else:
+75 dest_file = fr.filename + ",cover"
+ +77 with io.open(dest_file, 'w', encoding='utf8') as dest:
+78 i = 0
+79 j = 0
+80 covered = True
+81 source = fr.source()
+82 for lineno, line in enumerate(source.splitlines(True), start=1):
+83 while i < len(statements) and statements[i] < lineno:
+84 i += 1
+85 while j < len(missing) and missing[j] < lineno:
+86 j += 1
+87 if i < len(statements) and statements[i] == lineno:
+88 covered = j >= len(missing) or missing[j] > lineno
+89 if self.blank_re.match(line):
+90 dest.write(u' ')
+91 elif self.else_re.match(line):
+92 # Special logic for lines containing only 'else:'.
+93 if i >= len(statements) and j >= len(missing): 93 ↛ 94line 93 didn't jump to line 94, because the condition on line 93 was never true
+94 dest.write(u'! ')
+95 elif i >= len(statements) or j >= len(missing):
+96 dest.write(u'> ')
+97 elif statements[i] == missing[j]:
+98 dest.write(u'! ')
+99 else:
+100 dest.write(u'> ')
+101 elif lineno in excluded:
+102 dest.write(u'- ')
+103 elif covered:
+104 dest.write(u'> ')
+105 else:
+106 dest.write(u'! ')
+ +108 dest.write(line)
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Add things to old Pythons so I can pretend they are newer."""
+ +6# This file's purpose is to provide modules to be imported from here.
+7# pylint: disable=unused-import
+ +9import os
+10import sys
+ +12from datetime import datetime
+ +14from coverage import env
+ + +17# Pythons 2 and 3 differ on where to get StringIO.
+18try:
+19 from cStringIO import StringIO
+20except ImportError:
+21 from io import StringIO
+ +23# In py3, ConfigParser was renamed to the more-standard configparser.
+24# But there's a py3 backport that installs "configparser" in py2, and I don't
+25# want it because it has annoying deprecation warnings. So try the real py2
+26# import first.
+27try:
+28 import ConfigParser as configparser
+29except ImportError:
+30 import configparser
+ +32# What's a string called?
+33try:
+34 string_class = basestring
+35except NameError:
+36 string_class = str
+ +38# What's a Unicode string called?
+39try:
+40 unicode_class = unicode
+41except NameError:
+42 unicode_class = str
+ +44# range or xrange?
+45try:
+46 range = xrange # pylint: disable=redefined-builtin
+47except NameError:
+48 range = range
+ +50try:
+51 from itertools import zip_longest
+52except ImportError:
+53 from itertools import izip_longest as zip_longest
+ +55# Where do we get the thread id from?
+56try:
+57 from thread import get_ident as get_thread_id
+58except ImportError:
+59 from threading import get_ident as get_thread_id
+ +61try:
+62 os.PathLike
+63except AttributeError:
+64 # This is Python 2 and 3
+65 path_types = (bytes, string_class, unicode_class)
+66else:
+67 # 3.6+
+68 path_types = (bytes, str, os.PathLike)
+ +70# shlex.quote is new, but there's an undocumented implementation in "pipes",
+71# who knew!?
+72try:
+73 from shlex import quote as shlex_quote
+74except ImportError:
+75 # Useful function, available under a different (undocumented) name
+76 # in Python versions earlier than 3.3.
+77 from pipes import quote as shlex_quote
+ +79try:
+80 import reprlib
+81except ImportError: # pragma: not covered
+82 # We need this on Python 2, but in testing environments, a backport is
+83 # installed, so this import isn't used.
+84 import repr as reprlib
+ +86# A function to iterate listlessly over a dict's items, and one to get the
+87# items as a list.
+88try:
+89 {}.iteritems
+90except AttributeError:
+91 # Python 3
+92 def iitems(d):
+93 """Produce the items from dict `d`."""
+94 return d.items()
+ +96 def litems(d):
+97 """Return a list of items from dict `d`."""
+98 return list(d.items())
+99else:
+100 # Python 2
+101 def iitems(d):
+102 """Produce the items from dict `d`."""
+103 return d.iteritems()
+ +105 def litems(d):
+106 """Return a list of items from dict `d`."""
+107 return d.items()
+ +109# Getting the `next` function from an iterator is different in 2 and 3.
+110try:
+111 iter([]).next
+112except AttributeError:
+113 def iternext(seq):
+114 """Get the `next` function for iterating over `seq`."""
+115 return iter(seq).__next__
+116else:
+117 def iternext(seq):
+118 """Get the `next` function for iterating over `seq`."""
+119 return iter(seq).next
+ +121# Python 3.x is picky about bytes and strings, so provide methods to
+122# get them right, and make them no-ops in 2.x
+123if env.PY3:
+124 def to_bytes(s):
+125 """Convert string `s` to bytes."""
+126 return s.encode('utf8')
+ +128 def to_string(b):
+129 """Convert bytes `b` to string."""
+130 return b.decode('utf8')
+ +132 def binary_bytes(byte_values):
+133 """Produce a byte string with the ints from `byte_values`."""
+134 return bytes(byte_values)
+ +136 def byte_to_int(byte):
+137 """Turn a byte indexed from a bytes object into an int."""
+138 return byte
+ +140 def bytes_to_ints(bytes_value):
+141 """Turn a bytes object into a sequence of ints."""
+142 # In Python 3, iterating bytes gives ints.
+143 return bytes_value
+ +145else:
+146 def to_bytes(s):
+147 """Convert string `s` to bytes (no-op in 2.x)."""
+148 return s
+ +150 def to_string(b):
+151 """Convert bytes `b` to string."""
+152 return b
+ +154 def binary_bytes(byte_values):
+155 """Produce a byte string with the ints from `byte_values`."""
+156 return "".join(chr(b) for b in byte_values)
+ +158 def byte_to_int(byte):
+159 """Turn a byte indexed from a bytes object into an int."""
+160 return ord(byte)
+ +162 def bytes_to_ints(bytes_value):
+163 """Turn a bytes object into a sequence of ints."""
+164 for byte in bytes_value:
+165 yield ord(byte)
+ + +168try:
+169 # In Python 2.x, the builtins were in __builtin__
+170 BUILTINS = sys.modules['__builtin__']
+171except KeyError:
+172 # In Python 3.x, they're in builtins
+173 BUILTINS = sys.modules['builtins']
+ + +176# imp was deprecated in Python 3.3
+177try:
+178 import importlib
+179 import importlib.util
+180 imp = None
+181except ImportError:
+182 importlib = None
+ +184# We only want to use importlib if it has everything we need.
+185try:
+186 importlib_util_find_spec = importlib.util.find_spec
+187except Exception:
+188 import imp
+189 importlib_util_find_spec = None
+ +191# What is the .pyc magic number for this version of Python?
+192try:
+193 PYC_MAGIC_NUMBER = importlib.util.MAGIC_NUMBER
+194except AttributeError:
+195 PYC_MAGIC_NUMBER = imp.get_magic()
+ + +198def code_object(fn):
+199 """Get the code object from a function."""
+200 try:
+201 return fn.func_code
+202 except AttributeError:
+203 return fn.__code__
+ + +206try:
+207 from types import SimpleNamespace
+208except ImportError:
+209 # The code from https://docs.python.org/3/library/types.html#types.SimpleNamespace
+210 class SimpleNamespace:
+211 """Python implementation of SimpleNamespace, for Python 2."""
+212 def __init__(self, **kwargs):
+213 self.__dict__.update(kwargs)
+ +215 def __repr__(self):
+216 keys = sorted(self.__dict__)
+217 items = ("{}={!r}".format(k, self.__dict__[k]) for k in keys)
+218 return "{}({})".format(type(self).__name__, ", ".join(items))
+ + +221def format_local_datetime(dt):
+222 """Return a string with local timezone representing the date.
+223 If python version is lower than 3.6, the time zone is not included.
+224 """
+225 try:
+226 return dt.astimezone().strftime('%Y-%m-%d %H:%M %z')
+227 except (TypeError, ValueError):
+228 # Datetime.astimezone in Python 3.5 can not handle naive datetime
+229 return dt.strftime('%Y-%m-%d %H:%M')
+ + +232def import_local_file(modname, modfile=None):
+233 """Import a local file as a module.
+ +235 Opens a file in the current directory named `modname`.py, imports it
+236 as `modname`, and returns the module object. `modfile` is the file to
+237 import if it isn't in the current directory.
+ +239 """
+240 try:
+241 import importlib.util as importlib_util
+242 except ImportError:
+243 importlib_util = None
+ +245 if modfile is None: 245 ↛ 247line 245 didn't jump to line 247, because the condition on line 245 was never false
+246 modfile = modname + '.py'
+247 if importlib_util:
+248 spec = importlib_util.spec_from_file_location(modname, modfile)
+249 mod = importlib_util.module_from_spec(spec)
+250 sys.modules[modname] = mod
+251 spec.loader.exec_module(mod)
+252 else:
+253 for suff in imp.get_suffixes(): # pragma: part covered
+254 if suff[0] == '.py':
+255 break
+ +257 with open(modfile, 'r') as f:
+258 # pylint: disable=undefined-loop-variable
+259 mod = imp.load_module(modname, f, modfile, suff)
+ +261 return mod
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Bytecode manipulation for coverage.py"""
+ +6import types
+ + +9def code_objects(code):
+10 """Iterate over all the code objects in `code`."""
+11 stack = [code]
+12 while stack:
+13 # We're going to return the code object on the stack, but first
+14 # push its children for later returning.
+15 code = stack.pop()
+16 for c in code.co_consts:
+17 if isinstance(c, types.CodeType):
+18 stack.append(c)
+19 yield code
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Command-line support for coverage.py."""
+ +6from __future__ import print_function
+ +8import glob
+9import optparse
+10import os.path
+11import shlex
+12import sys
+13import textwrap
+14import traceback
+ +16import coverage
+17from coverage import Coverage
+18from coverage import env
+19from coverage.collector import CTracer
+20from coverage.data import line_counts
+21from coverage.debug import info_formatter, info_header, short_stack
+22from coverage.execfile import PyRunner
+23from coverage.misc import BaseCoverageException, ExceptionDuringRun, NoSource, output_encoding
+24from coverage.results import should_fail_under
+ + +27class Opts(object):
+28 """A namespace class for individual options we'll build parsers from."""
+ +30 append = optparse.make_option(
+31 '-a', '--append', action='store_true',
+32 help="Append coverage data to .coverage, otherwise it starts clean each time.",
+33 )
+34 keep = optparse.make_option(
+35 '', '--keep', action='store_true',
+36 help="Keep original coverage files, otherwise they are deleted.",
+37 )
+38 branch = optparse.make_option(
+39 '', '--branch', action='store_true',
+40 help="Measure branch coverage in addition to statement coverage.",
+41 )
+42 CONCURRENCY_CHOICES = [
+43 "thread", "gevent", "greenlet", "eventlet", "multiprocessing",
+44 ]
+45 concurrency = optparse.make_option(
+46 '', '--concurrency', action='store', metavar="LIB",
+47 choices=CONCURRENCY_CHOICES,
+48 help=(
+49 "Properly measure code using a concurrency library. "
+50 "Valid values are: %s."
+51 ) % ", ".join(CONCURRENCY_CHOICES),
+52 )
+53 context = optparse.make_option(
+54 '', '--context', action='store', metavar="LABEL",
+55 help="The context label to record for this coverage run.",
+56 )
+57 debug = optparse.make_option(
+58 '', '--debug', action='store', metavar="OPTS",
+59 help="Debug options, separated by commas. [env: COVERAGE_DEBUG]",
+60 )
+61 directory = optparse.make_option(
+62 '-d', '--directory', action='store', metavar="DIR",
+63 help="Write the output files to DIR.",
+64 )
+65 fail_under = optparse.make_option(
+66 '', '--fail-under', action='store', metavar="MIN", type="float",
+67 help="Exit with a status of 2 if the total coverage is less than MIN.",
+68 )
+69 help = optparse.make_option(
+70 '-h', '--help', action='store_true',
+71 help="Get help on this command.",
+72 )
+73 ignore_errors = optparse.make_option(
+74 '-i', '--ignore-errors', action='store_true',
+75 help="Ignore errors while reading source files.",
+76 )
+77 include = optparse.make_option(
+78 '', '--include', action='store',
+79 metavar="PAT1,PAT2,...",
+80 help=(
+81 "Include only files whose paths match one of these patterns. "
+82 "Accepts shell-style wildcards, which must be quoted."
+83 ),
+84 )
+85 pylib = optparse.make_option(
+86 '-L', '--pylib', action='store_true',
+87 help=(
+88 "Measure coverage even inside the Python installed library, "
+89 "which isn't done by default."
+90 ),
+91 )
+92 sort = optparse.make_option(
+93 '--sort', action='store', metavar='COLUMN',
+94 help="Sort the report by the named column: name, stmts, miss, branch, brpart, or cover. "
+95 "Default is name."
+96 )
+97 show_missing = optparse.make_option(
+98 '-m', '--show-missing', action='store_true',
+99 help="Show line numbers of statements in each module that weren't executed.",
+100 )
+101 skip_covered = optparse.make_option(
+102 '--skip-covered', action='store_true',
+103 help="Skip files with 100% coverage.",
+104 )
+105 no_skip_covered = optparse.make_option(
+106 '--no-skip-covered', action='store_false', dest='skip_covered',
+107 help="Disable --skip-covered.",
+108 )
+109 skip_empty = optparse.make_option(
+110 '--skip-empty', action='store_true',
+111 help="Skip files with no code.",
+112 )
+113 show_contexts = optparse.make_option(
+114 '--show-contexts', action='store_true',
+115 help="Show contexts for covered lines.",
+116 )
+117 omit = optparse.make_option(
+118 '', '--omit', action='store',
+119 metavar="PAT1,PAT2,...",
+120 help=(
+121 "Omit files whose paths match one of these patterns. "
+122 "Accepts shell-style wildcards, which must be quoted."
+123 ),
+124 )
+125 contexts = optparse.make_option(
+126 '', '--contexts', action='store',
+127 metavar="REGEX1,REGEX2,...",
+128 help=(
+129 "Only display data from lines covered in the given contexts. "
+130 "Accepts Python regexes, which must be quoted."
+131 ),
+132 )
+133 output_xml = optparse.make_option(
+134 '-o', '', action='store', dest="outfile",
+135 metavar="OUTFILE",
+136 help="Write the XML report to this file. Defaults to 'coverage.xml'",
+137 )
+138 output_json = optparse.make_option(
+139 '-o', '', action='store', dest="outfile",
+140 metavar="OUTFILE",
+141 help="Write the JSON report to this file. Defaults to 'coverage.json'",
+142 )
+143 json_pretty_print = optparse.make_option(
+144 '', '--pretty-print', action='store_true',
+145 help="Format the JSON for human readers.",
+146 )
+147 parallel_mode = optparse.make_option(
+148 '-p', '--parallel-mode', action='store_true',
+149 help=(
+150 "Append the machine name, process id and random number to the "
+151 ".coverage data file name to simplify collecting data from "
+152 "many processes."
+153 ),
+154 )
+155 module = optparse.make_option(
+156 '-m', '--module', action='store_true',
+157 help=(
+158 "<pyfile> is an importable Python module, not a script path, "
+159 "to be run as 'python -m' would run it."
+160 ),
+161 )
+162 precision = optparse.make_option(
+163 '', '--precision', action='store', metavar='N', type=int,
+164 help=(
+165 "Number of digits after the decimal point to display for "
+166 "reported coverage percentages."
+167 ),
+168 )
+169 rcfile = optparse.make_option(
+170 '', '--rcfile', action='store',
+171 help=(
+172 "Specify configuration file. "
+173 "By default '.coveragerc', 'setup.cfg', 'tox.ini', and "
+174 "'pyproject.toml' are tried. [env: COVERAGE_RCFILE]"
+175 ),
+176 )
+177 source = optparse.make_option(
+178 '', '--source', action='store', metavar="SRC1,SRC2,...",
+179 help="A list of directories or importable names of code to measure.",
+180 )
+181 timid = optparse.make_option(
+182 '', '--timid', action='store_true',
+183 help=(
+184 "Use a simpler but slower trace method. Try this if you get "
+185 "seemingly impossible results!"
+186 ),
+187 )
+188 title = optparse.make_option(
+189 '', '--title', action='store', metavar="TITLE",
+190 help="A text string to use as the title on the HTML.",
+191 )
+192 version = optparse.make_option(
+193 '', '--version', action='store_true',
+194 help="Display version information and exit.",
+195 )
+ + +198class CoverageOptionParser(optparse.OptionParser, object):
+199 """Base OptionParser for coverage.py.
+ +201 Problems don't exit the program.
+202 Defaults are initialized for all options.
+ +204 """
+ +206 def __init__(self, *args, **kwargs):
+207 super(CoverageOptionParser, self).__init__(
+208 add_help_option=False, *args, **kwargs
+209 )
+210 self.set_defaults(
+211 action=None,
+212 append=None,
+213 branch=None,
+214 concurrency=None,
+215 context=None,
+216 debug=None,
+217 directory=None,
+218 fail_under=None,
+219 help=None,
+220 ignore_errors=None,
+221 include=None,
+222 keep=None,
+223 module=None,
+224 omit=None,
+225 contexts=None,
+226 parallel_mode=None,
+227 precision=None,
+228 pylib=None,
+229 rcfile=True,
+230 show_missing=None,
+231 skip_covered=None,
+232 skip_empty=None,
+233 show_contexts=None,
+234 sort=None,
+235 source=None,
+236 timid=None,
+237 title=None,
+238 version=None,
+239 )
+ +241 self.disable_interspersed_args()
+ +243 class OptionParserError(Exception):
+244 """Used to stop the optparse error handler ending the process."""
+245 pass
+ +247 def parse_args_ok(self, args=None, options=None):
+248 """Call optparse.parse_args, but return a triple:
+ +250 (ok, options, args)
+ +252 """
+253 try:
+254 options, args = super(CoverageOptionParser, self).parse_args(args, options)
+255 except self.OptionParserError:
+256 return False, None, None
+257 return True, options, args
+ +259 def error(self, msg):
+260 """Override optparse.error so sys.exit doesn't get called."""
+261 show_help(msg)
+262 raise self.OptionParserError
+ + +265class GlobalOptionParser(CoverageOptionParser):
+266 """Command-line parser for coverage.py global option arguments."""
+ +268 def __init__(self):
+269 super(GlobalOptionParser, self).__init__()
+ +271 self.add_options([
+272 Opts.help,
+273 Opts.version,
+274 ])
+ + +277class CmdOptionParser(CoverageOptionParser):
+278 """Parse one of the new-style commands for coverage.py."""
+ +280 def __init__(self, action, options, defaults=None, usage=None, description=None):
+281 """Create an OptionParser for a coverage.py command.
+ +283 `action` is the slug to put into `options.action`.
+284 `options` is a list of Option's for the command.
+285 `defaults` is a dict of default value for options.
+286 `usage` is the usage string to display in help.
+287 `description` is the description of the command, for the help text.
+ +289 """
+290 if usage:
+291 usage = "%prog " + usage
+292 super(CmdOptionParser, self).__init__(
+293 usage=usage,
+294 description=description,
+295 )
+296 self.set_defaults(action=action, **(defaults or {}))
+297 self.add_options(options)
+298 self.cmd = action
+ +300 def __eq__(self, other):
+301 # A convenience equality, so that I can put strings in unit test
+302 # results, and they will compare equal to objects.
+303 return (other == "<CmdOptionParser:%s>" % self.cmd)
+ +305 __hash__ = None # This object doesn't need to be hashed.
+ +307 def get_prog_name(self):
+308 """Override of an undocumented function in optparse.OptionParser."""
+309 program_name = super(CmdOptionParser, self).get_prog_name()
+ +311 # Include the sub-command for this parser as part of the command.
+312 return "{command} {subcommand}".format(command=program_name, subcommand=self.cmd)
+ + +315GLOBAL_ARGS = [
+316 Opts.debug,
+317 Opts.help,
+318 Opts.rcfile,
+319 ]
+ +321CMDS = {
+322 'annotate': CmdOptionParser(
+323 "annotate",
+324 [
+325 Opts.directory,
+326 Opts.ignore_errors,
+327 Opts.include,
+328 Opts.omit,
+329 ] + GLOBAL_ARGS,
+330 usage="[options] [modules]",
+331 description=(
+332 "Make annotated copies of the given files, marking statements that are executed "
+333 "with > and statements that are missed with !."
+334 ),
+335 ),
+ +337 'combine': CmdOptionParser(
+338 "combine",
+339 [
+340 Opts.append,
+341 Opts.keep,
+342 ] + GLOBAL_ARGS,
+343 usage="[options] <path1> <path2> ... <pathN>",
+344 description=(
+345 "Combine data from multiple coverage files collected "
+346 "with 'run -p'. The combined results are written to a single "
+347 "file representing the union of the data. The positional "
+348 "arguments are data files or directories containing data files. "
+349 "If no paths are provided, data files in the default data file's "
+350 "directory are combined."
+351 ),
+352 ),
+ +354 'debug': CmdOptionParser(
+355 "debug", GLOBAL_ARGS,
+356 usage="<topic>",
+357 description=(
+358 "Display information about the internals of coverage.py, "
+359 "for diagnosing problems. "
+360 "Topics are: "
+361 "'data' to show a summary of the collected data; "
+362 "'sys' to show installation information; "
+363 "'config' to show the configuration; "
+364 "'premain' to show what is calling coverage."
+365 ),
+366 ),
+ +368 'erase': CmdOptionParser(
+369 "erase", GLOBAL_ARGS,
+370 description="Erase previously collected coverage data.",
+371 ),
+ +373 'help': CmdOptionParser(
+374 "help", GLOBAL_ARGS,
+375 usage="[command]",
+376 description="Describe how to use coverage.py",
+377 ),
+ +379 'html': CmdOptionParser(
+380 "html",
+381 [
+382 Opts.contexts,
+383 Opts.directory,
+384 Opts.fail_under,
+385 Opts.ignore_errors,
+386 Opts.include,
+387 Opts.omit,
+388 Opts.precision,
+389 Opts.show_contexts,
+390 Opts.skip_covered,
+391 Opts.no_skip_covered,
+392 Opts.skip_empty,
+393 Opts.title,
+394 ] + GLOBAL_ARGS,
+395 usage="[options] [modules]",
+396 description=(
+397 "Create an HTML report of the coverage of the files. "
+398 "Each file gets its own page, with the source decorated to show "
+399 "executed, excluded, and missed lines."
+400 ),
+401 ),
+ +403 'json': CmdOptionParser(
+404 "json",
+405 [
+406 Opts.contexts,
+407 Opts.fail_under,
+408 Opts.ignore_errors,
+409 Opts.include,
+410 Opts.omit,
+411 Opts.output_json,
+412 Opts.json_pretty_print,
+413 Opts.show_contexts,
+414 ] + GLOBAL_ARGS,
+415 usage="[options] [modules]",
+416 description="Generate a JSON report of coverage results."
+417 ),
+ +419 'report': CmdOptionParser(
+420 "report",
+421 [
+422 Opts.contexts,
+423 Opts.fail_under,
+424 Opts.ignore_errors,
+425 Opts.include,
+426 Opts.omit,
+427 Opts.precision,
+428 Opts.sort,
+429 Opts.show_missing,
+430 Opts.skip_covered,
+431 Opts.no_skip_covered,
+432 Opts.skip_empty,
+433 ] + GLOBAL_ARGS,
+434 usage="[options] [modules]",
+435 description="Report coverage statistics on modules."
+436 ),
+ +438 'run': CmdOptionParser(
+439 "run",
+440 [
+441 Opts.append,
+442 Opts.branch,
+443 Opts.concurrency,
+444 Opts.context,
+445 Opts.include,
+446 Opts.module,
+447 Opts.omit,
+448 Opts.pylib,
+449 Opts.parallel_mode,
+450 Opts.source,
+451 Opts.timid,
+452 ] + GLOBAL_ARGS,
+453 usage="[options] <pyfile> [program options]",
+454 description="Run a Python program, measuring code execution."
+455 ),
+ +457 'xml': CmdOptionParser(
+458 "xml",
+459 [
+460 Opts.fail_under,
+461 Opts.ignore_errors,
+462 Opts.include,
+463 Opts.omit,
+464 Opts.output_xml,
+465 Opts.skip_empty,
+466 ] + GLOBAL_ARGS,
+467 usage="[options] [modules]",
+468 description="Generate an XML report of coverage results."
+469 ),
+470}
+ + +473def show_help(error=None, topic=None, parser=None):
+474 """Display an error message, or the named topic."""
+475 assert error or topic or parser
+ +477 program_path = sys.argv[0]
+478 if program_path.endswith(os.path.sep + '__main__.py'):
+479 # The path is the main module of a package; get that path instead.
+480 program_path = os.path.dirname(program_path)
+481 program_name = os.path.basename(program_path)
+482 if env.WINDOWS:
+483 # entry_points={'console_scripts':...} on Windows makes files
+484 # called coverage.exe, coverage3.exe, and coverage-3.5.exe. These
+485 # invoke coverage-script.py, coverage3-script.py, and
+486 # coverage-3.5-script.py. argv[0] is the .py file, but we want to
+487 # get back to the original form.
+488 auto_suffix = "-script.py"
+489 if program_name.endswith(auto_suffix): 489 ↛ 490line 489 didn't jump to line 490, because the condition on line 489 was never true
+490 program_name = program_name[:-len(auto_suffix)]
+ +492 help_params = dict(coverage.__dict__)
+493 help_params['program_name'] = program_name
+494 if CTracer is not None:
+495 help_params['extension_modifier'] = 'with C extension'
+496 else:
+497 help_params['extension_modifier'] = 'without C extension'
+ +499 if error:
+500 print(error, file=sys.stderr)
+501 print("Use '%s help' for help." % (program_name,), file=sys.stderr)
+502 elif parser:
+503 print(parser.format_help().strip())
+504 print()
+505 else:
+506 help_msg = textwrap.dedent(HELP_TOPICS.get(topic, '')).strip()
+507 if help_msg:
+508 print(help_msg.format(**help_params))
+509 else:
+510 print("Don't know topic %r" % topic)
+511 print("Full documentation is at {__url__}".format(**help_params))
+ + +514OK, ERR, FAIL_UNDER = 0, 1, 2
+ + +517class CoverageScript(object):
+518 """The command-line interface to coverage.py."""
+ +520 def __init__(self):
+521 self.global_option = False
+522 self.coverage = None
+ +524 def command_line(self, argv):
+525 """The bulk of the command line interface to coverage.py.
+ +527 `argv` is the argument list to process.
+ +529 Returns 0 if all is well, 1 if something went wrong.
+ +531 """
+532 # Collect the command-line options.
+533 if not argv:
+534 show_help(topic='minimum_help')
+535 return OK
+ +537 # The command syntax we parse depends on the first argument. Global
+538 # switch syntax always starts with an option.
+539 self.global_option = argv[0].startswith('-')
+540 if self.global_option:
+541 parser = GlobalOptionParser()
+542 else:
+543 parser = CMDS.get(argv[0])
+544 if not parser:
+545 show_help("Unknown command: '%s'" % argv[0])
+546 return ERR
+547 argv = argv[1:]
+ +549 ok, options, args = parser.parse_args_ok(argv)
+550 if not ok:
+551 return ERR
+ +553 # Handle help and version.
+554 if self.do_help(options, args, parser):
+555 return OK
+ +557 # Listify the list options.
+558 source = unshell_list(options.source)
+559 omit = unshell_list(options.omit)
+560 include = unshell_list(options.include)
+561 debug = unshell_list(options.debug)
+562 contexts = unshell_list(options.contexts)
+ +564 # Do something.
+565 self.coverage = Coverage(
+566 data_suffix=options.parallel_mode,
+567 cover_pylib=options.pylib,
+568 timid=options.timid,
+569 branch=options.branch,
+570 config_file=options.rcfile,
+571 source=source,
+572 omit=omit,
+573 include=include,
+574 debug=debug,
+575 concurrency=options.concurrency,
+576 check_preimported=True,
+577 context=options.context,
+578 )
+ +580 if options.action == "debug":
+581 return self.do_debug(args)
+ +583 elif options.action == "erase":
+584 self.coverage.erase()
+585 return OK
+ +587 elif options.action == "run":
+588 return self.do_run(options, args)
+ +590 elif options.action == "combine":
+591 if options.append:
+592 self.coverage.load()
+593 data_dirs = args or None
+594 self.coverage.combine(data_dirs, strict=True, keep=bool(options.keep))
+595 self.coverage.save()
+596 return OK
+ +598 # Remaining actions are reporting, with some common options.
+599 report_args = dict(
+600 morfs=unglob_args(args),
+601 ignore_errors=options.ignore_errors,
+602 omit=omit,
+603 include=include,
+604 contexts=contexts,
+605 )
+ +607 # We need to be able to import from the current directory, because
+608 # plugins may try to, for example, to read Django settings.
+609 sys.path.insert(0, '')
+ +611 self.coverage.load()
+ +613 total = None
+614 if options.action == "report":
+615 total = self.coverage.report(
+616 show_missing=options.show_missing,
+617 skip_covered=options.skip_covered,
+618 skip_empty=options.skip_empty,
+619 precision=options.precision,
+620 sort=options.sort,
+621 **report_args
+622 )
+623 elif options.action == "annotate":
+624 self.coverage.annotate(directory=options.directory, **report_args)
+625 elif options.action == "html":
+626 total = self.coverage.html_report(
+627 directory=options.directory,
+628 title=options.title,
+629 skip_covered=options.skip_covered,
+630 skip_empty=options.skip_empty,
+631 show_contexts=options.show_contexts,
+632 precision=options.precision,
+633 **report_args
+634 )
+635 elif options.action == "xml":
+636 outfile = options.outfile
+637 total = self.coverage.xml_report(
+638 outfile=outfile, skip_empty=options.skip_empty,
+639 **report_args
+640 )
+641 elif options.action == "json": 641 ↛ 650line 641 didn't jump to line 650, because the condition on line 641 was never false
+642 outfile = options.outfile
+643 total = self.coverage.json_report(
+644 outfile=outfile,
+645 pretty_print=options.pretty_print,
+646 show_contexts=options.show_contexts,
+647 **report_args
+648 )
+ +650 if total is not None:
+651 # Apply the command line fail-under options, and then use the config
+652 # value, so we can get fail_under from the config file.
+653 if options.fail_under is not None:
+654 self.coverage.set_option("report:fail_under", options.fail_under)
+ +656 fail_under = self.coverage.get_option("report:fail_under")
+657 precision = self.coverage.get_option("report:precision")
+658 if should_fail_under(total, fail_under, precision):
+659 msg = "total of {total:.{p}f} is less than fail-under={fail_under:.{p}f}".format(
+660 total=total, fail_under=fail_under, p=precision,
+661 )
+662 print("Coverage failure:", msg)
+663 return FAIL_UNDER
+ +665 return OK
+ +667 def do_help(self, options, args, parser):
+668 """Deal with help requests.
+ +670 Return True if it handled the request, False if not.
+ +672 """
+673 # Handle help.
+674 if options.help:
+675 if self.global_option:
+676 show_help(topic='help')
+677 else:
+678 show_help(parser=parser)
+679 return True
+ +681 if options.action == "help":
+682 if args:
+683 for a in args:
+684 parser = CMDS.get(a)
+685 if parser:
+686 show_help(parser=parser)
+687 else:
+688 show_help(topic=a)
+689 else:
+690 show_help(topic='help')
+691 return True
+ +693 # Handle version.
+694 if options.version:
+695 show_help(topic='version')
+696 return True
+ +698 return False
+ +700 def do_run(self, options, args):
+701 """Implementation of 'coverage run'."""
+ +703 if not args:
+704 if options.module:
+705 # Specified -m with nothing else.
+706 show_help("No module specified for -m")
+707 return ERR
+708 command_line = self.coverage.get_option("run:command_line")
+709 if command_line is not None:
+710 args = shlex.split(command_line)
+711 if args and args[0] == "-m":
+712 options.module = True
+713 args = args[1:]
+714 if not args:
+715 show_help("Nothing to do.")
+716 return ERR
+ +718 if options.append and self.coverage.get_option("run:parallel"):
+719 show_help("Can't append to data files in parallel mode.")
+720 return ERR
+ +722 if options.concurrency == "multiprocessing":
+723 # Can't set other run-affecting command line options with
+724 # multiprocessing.
+725 for opt_name in ['branch', 'include', 'omit', 'pylib', 'source', 'timid']:
+726 # As it happens, all of these options have no default, meaning
+727 # they will be None if they have not been specified.
+728 if getattr(options, opt_name) is not None:
+729 show_help(
+730 "Options affecting multiprocessing must only be specified "
+731 "in a configuration file.\n"
+732 "Remove --{} from the command line.".format(opt_name)
+733 )
+734 return ERR
+ +736 runner = PyRunner(args, as_module=bool(options.module))
+737 runner.prepare()
+ +739 if options.append:
+740 self.coverage.load()
+ +742 # Run the script.
+743 self.coverage.start()
+744 code_ran = True
+745 try:
+746 runner.run()
+747 except NoSource:
+748 code_ran = False
+749 raise
+750 finally:
+751 self.coverage.stop()
+752 if code_ran: 752 ↛ 755line 752 didn't jump to line 755, because the condition on line 752 was never false
+753 self.coverage.save()
+ +755 return OK
+ +757 def do_debug(self, args):
+758 """Implementation of 'coverage debug'."""
+ +760 if not args:
+761 show_help("What information would you like: config, data, sys, premain?")
+762 return ERR
+ +764 for info in args:
+765 if info == 'sys':
+766 sys_info = self.coverage.sys_info()
+767 print(info_header("sys"))
+768 for line in info_formatter(sys_info):
+769 print(" %s" % line)
+770 elif info == 'data':
+771 self.coverage.load()
+772 data = self.coverage.get_data()
+773 print(info_header("data"))
+774 print("path: %s" % data.data_filename())
+775 if data:
+776 print("has_arcs: %r" % data.has_arcs())
+777 summary = line_counts(data, fullpath=True)
+778 filenames = sorted(summary.keys())
+779 print("\n%d files:" % len(filenames))
+780 for f in filenames:
+781 line = "%s: %d lines" % (f, summary[f])
+782 plugin = data.file_tracer(f)
+783 if plugin:
+784 line += " [%s]" % plugin
+785 print(line)
+786 else:
+787 print("No data collected")
+788 elif info == 'config':
+789 print(info_header("config"))
+790 config_info = self.coverage.config.__dict__.items()
+791 for line in info_formatter(config_info):
+792 print(" %s" % line)
+793 elif info == "premain": 793 ↛ 794line 793 didn't jump to line 794, because the condition on line 793 was never true
+794 print(info_header("premain"))
+795 print(short_stack())
+796 else:
+797 show_help("Don't know what you mean by %r" % info)
+798 return ERR
+ +800 return OK
+ + +803def unshell_list(s):
+804 """Turn a command-line argument into a list."""
+805 if not s:
+806 return None
+807 if env.WINDOWS:
+808 # When running coverage.py as coverage.exe, some of the behavior
+809 # of the shell is emulated: wildcards are expanded into a list of
+810 # file names. So you have to single-quote patterns on the command
+811 # line, but (not) helpfully, the single quotes are included in the
+812 # argument, so we have to strip them off here.
+813 s = s.strip("'")
+814 return s.split(',')
+ + +817def unglob_args(args):
+818 """Interpret shell wildcards for platforms that need it."""
+819 if env.WINDOWS:
+820 globbed = []
+821 for arg in args:
+822 if '?' in arg or '*' in arg:
+823 globbed.extend(glob.glob(arg))
+824 else:
+825 globbed.append(arg)
+826 args = globbed
+827 return args
+ + +830HELP_TOPICS = {
+831 'help': """\
+832 Coverage.py, version {__version__} {extension_modifier}
+833 Measure, collect, and report on code coverage in Python programs.
+ +835 usage: {program_name} <command> [options] [args]
+ +837 Commands:
+838 annotate Annotate source files with execution information.
+839 combine Combine a number of data files.
+840 debug Display information about the internals of coverage.py
+841 erase Erase previously collected coverage data.
+842 help Get help on using coverage.py.
+843 html Create an HTML report.
+844 json Create a JSON report of coverage results.
+845 report Report coverage stats on modules.
+846 run Run a Python program and measure code execution.
+847 xml Create an XML report of coverage results.
+ +849 Use "{program_name} help <command>" for detailed help on any command.
+850 """,
+ +852 'minimum_help': """\
+853 Code coverage for Python, version {__version__} {extension_modifier}. Use '{program_name} help' for help.
+854 """,
+ +856 'version': """\
+857 Coverage.py, version {__version__} {extension_modifier}
+858 """,
+859}
+ + +862def main(argv=None):
+863 """The main entry point to coverage.py.
+ +865 This is installed as the script entry point.
+ +867 """
+868 if argv is None:
+869 argv = sys.argv[1:]
+870 try:
+871 status = CoverageScript().command_line(argv)
+872 except ExceptionDuringRun as err:
+873 # An exception was caught while running the product code. The
+874 # sys.exc_info() return tuple is packed into an ExceptionDuringRun
+875 # exception.
+876 traceback.print_exception(*err.args) # pylint: disable=no-value-for-parameter
+877 status = ERR
+878 except BaseCoverageException as err:
+879 # A controlled error inside coverage.py: print the message to the user.
+880 msg = err.args[0]
+881 if env.PY2:
+882 msg = msg.encode(output_encoding())
+883 print(msg)
+884 status = ERR
+885 except SystemExit as err:
+886 # The user called `sys.exit()`. Exit with their argument, if any.
+887 if err.args:
+888 status = err.args[0]
+889 else:
+890 status = None
+891 return status
+ +893# Profiling using ox_profile. Install it from GitHub:
+894# pip install git+https://github.com/emin63/ox_profile.git
+895#
+896# $set_env.py: COVERAGE_PROFILE - Set to use ox_profile.
+897_profile = os.environ.get("COVERAGE_PROFILE", "")
+898if _profile: # pragma: debugging
+899 from ox_profile.core.launchers import SimpleLauncher # pylint: disable=import-error
+900 original_main = main
+ +902 def main(argv=None): # pylint: disable=function-redefined
+903 """A wrapper around main that profiles."""
+904 profiler = SimpleLauncher.launch()
+905 try:
+906 return original_main(argv)
+907 finally:
+908 data, _ = profiler.query(re_filter='coverage', max_records=100)
+909 print(profiler.show(query=data, limit=100, sep='', col=''))
+910 profiler.cancel()
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Raw data collector for coverage.py."""
+ +6import os
+7import sys
+ +9from coverage import env
+10from coverage.backward import litems, range # pylint: disable=redefined-builtin
+11from coverage.debug import short_stack
+12from coverage.disposition import FileDisposition
+13from coverage.misc import CoverageException, isolate_module
+14from coverage.pytracer import PyTracer
+ +16os = isolate_module(os)
+ + +19try:
+20 # Use the C extension code when we can, for speed.
+21 from coverage.tracer import CTracer, CFileDisposition
+22except ImportError:
+23 # Couldn't import the C extension, maybe it isn't built.
+24 if os.getenv('COVERAGE_TEST_TRACER') == 'c': 24 ↛ 31line 24 didn't jump to line 31, because the condition on line 24 was never true
+25 # During testing, we use the COVERAGE_TEST_TRACER environment variable
+26 # to indicate that we've fiddled with the environment to test this
+27 # fallback code. If we thought we had a C tracer, but couldn't import
+28 # it, then exit quickly and clearly instead of dribbling confusing
+29 # errors. I'm using sys.exit here instead of an exception because an
+30 # exception here causes all sorts of other noise in unittest.
+31 sys.stderr.write("*** COVERAGE_TEST_TRACER is 'c' but can't import CTracer!\n")
+32 sys.exit(1)
+33 CTracer = None
+ + +36class Collector(object):
+37 """Collects trace data.
+ +39 Creates a Tracer object for each thread, since they track stack
+40 information. Each Tracer points to the same shared data, contributing
+41 traced data points.
+ +43 When the Collector is started, it creates a Tracer for the current thread,
+44 and installs a function to create Tracers for each new thread started.
+45 When the Collector is stopped, all active Tracers are stopped.
+ +47 Threads started while the Collector is stopped will never have Tracers
+48 associated with them.
+ +50 """
+ +52 # The stack of active Collectors. Collectors are added here when started,
+53 # and popped when stopped. Collectors on the stack are paused when not
+54 # the top, and resumed when they become the top again.
+55 _collectors = []
+ +57 # The concurrency settings we support here.
+58 SUPPORTED_CONCURRENCIES = {"greenlet", "eventlet", "gevent", "thread"}
+ +60 def __init__(
+61 self, should_trace, check_include, should_start_context, file_mapper,
+62 timid, branch, warn, concurrency,
+63 ):
+64 """Create a collector.
+ +66 `should_trace` is a function, taking a file name and a frame, and
+67 returning a `coverage.FileDisposition object`.
+ +69 `check_include` is a function taking a file name and a frame. It returns
+70 a boolean: True if the file should be traced, False if not.
+ +72 `should_start_context` is a function taking a frame, and returning a
+73 string. If the frame should be the start of a new context, the string
+74 is the new context. If the frame should not be the start of a new
+75 context, return None.
+ +77 `file_mapper` is a function taking a filename, and returning a Unicode
+78 filename. The result is the name that will be recorded in the data
+79 file.
+ +81 If `timid` is true, then a slower simpler trace function will be
+82 used. This is important for some environments where manipulation of
+83 tracing functions make the faster more sophisticated trace function not
+84 operate properly.
+ +86 If `branch` is true, then branches will be measured. This involves
+87 collecting data on which statements followed each other (arcs). Use
+88 `get_arc_data` to get the arc data.
+ +90 `warn` is a warning function, taking a single string message argument
+91 and an optional slug argument which will be a string or None, to be
+92 used if a warning needs to be issued.
+ +94 `concurrency` is a list of strings indicating the concurrency libraries
+95 in use. Valid values are "greenlet", "eventlet", "gevent", or "thread"
+96 (the default). Of these four values, only one can be supplied. Other
+97 values are ignored.
+ +99 """
+100 self.should_trace = should_trace
+101 self.check_include = check_include
+102 self.should_start_context = should_start_context
+103 self.file_mapper = file_mapper
+104 self.warn = warn
+105 self.branch = branch
+106 self.threading = None
+107 self.covdata = None
+ +109 self.static_context = None
+ +111 self.origin = short_stack()
+ +113 self.concur_id_func = None
+114 self.mapped_file_cache = {}
+ +116 # We can handle a few concurrency options here, but only one at a time.
+117 these_concurrencies = self.SUPPORTED_CONCURRENCIES.intersection(concurrency)
+118 if len(these_concurrencies) > 1: 118 ↛ 119line 118 didn't jump to line 119, because the condition on line 118 was never true
+119 raise CoverageException("Conflicting concurrency settings: %s" % concurrency)
+120 self.concurrency = these_concurrencies.pop() if these_concurrencies else ''
+ +122 try:
+123 if self.concurrency == "greenlet":
+124 import greenlet
+125 self.concur_id_func = greenlet.getcurrent
+126 elif self.concurrency == "eventlet":
+127 import eventlet.greenthread # pylint: disable=import-error,useless-suppression
+128 self.concur_id_func = eventlet.greenthread.getcurrent
+129 elif self.concurrency == "gevent":
+130 import gevent # pylint: disable=import-error,useless-suppression
+131 self.concur_id_func = gevent.getcurrent
+132 elif self.concurrency == "thread" or not self.concurrency: 132 ↛ 139line 132 didn't jump to line 139, because the condition on line 132 was never false
+133 # It's important to import threading only if we need it. If
+134 # it's imported early, and the program being measured uses
+135 # gevent, then gevent's monkey-patching won't work properly.
+136 import threading
+137 self.threading = threading
+138 else:
+139 raise CoverageException("Don't understand concurrency=%s" % concurrency)
+140 except ImportError:
+141 raise CoverageException(
+142 "Couldn't trace with concurrency=%s, the module isn't installed." % (
+143 self.concurrency,
+144 )
+145 )
+ +147 self.reset()
+ +149 if timid:
+150 # Being timid: use the simple Python trace function.
+151 self._trace_class = PyTracer
+152 else:
+153 # Being fast: use the C Tracer if it is available, else the Python
+154 # trace function.
+155 self._trace_class = CTracer or PyTracer
+ +157 if self._trace_class is CTracer:
+158 self.file_disposition_class = CFileDisposition
+159 self.supports_plugins = True
+160 else:
+161 self.file_disposition_class = FileDisposition
+162 self.supports_plugins = False
+ +164 def __repr__(self):
+165 return "<Collector at 0x%x: %s>" % (id(self), self.tracer_name())
+ +167 def use_data(self, covdata, context):
+168 """Use `covdata` for recording data."""
+169 self.covdata = covdata
+170 self.static_context = context
+171 self.covdata.set_context(self.static_context)
+ +173 def tracer_name(self):
+174 """Return the class name of the tracer we're using."""
+175 return self._trace_class.__name__
+ +177 def _clear_data(self):
+178 """Clear out existing data, but stay ready for more collection."""
+179 # We used to used self.data.clear(), but that would remove filename
+180 # keys and data values that were still in use higher up the stack
+181 # when we are called as part of switch_context.
+182 for d in self.data.values():
+183 d.clear()
+ +185 for tracer in self.tracers:
+186 tracer.reset_activity()
+ +188 def reset(self):
+189 """Clear collected data, and prepare to collect more."""
+190 # A dictionary mapping file names to dicts with line number keys (if not
+191 # branch coverage), or mapping file names to dicts with line number
+192 # pairs as keys (if branch coverage).
+193 self.data = {}
+ +195 # A dictionary mapping file names to file tracer plugin names that will
+196 # handle them.
+197 self.file_tracers = {}
+ +199 self.disabled_plugins = set()
+ +201 # The .should_trace_cache attribute is a cache from file names to
+202 # coverage.FileDisposition objects, or None. When a file is first
+203 # considered for tracing, a FileDisposition is obtained from
+204 # Coverage.should_trace. Its .trace attribute indicates whether the
+205 # file should be traced or not. If it should be, a plugin with dynamic
+206 # file names can decide not to trace it based on the dynamic file name
+207 # being excluded by the inclusion rules, in which case the
+208 # FileDisposition will be replaced by None in the cache.
+209 if env.PYPY:
+210 import __pypy__ # pylint: disable=import-error
+211 # Alex Gaynor said:
+212 # should_trace_cache is a strictly growing key: once a key is in
+213 # it, it never changes. Further, the keys used to access it are
+214 # generally constant, given sufficient context. That is to say, at
+215 # any given point _trace() is called, pypy is able to know the key.
+216 # This is because the key is determined by the physical source code
+217 # line, and that's invariant with the call site.
+218 #
+219 # This property of a dict with immutable keys, combined with
+220 # call-site-constant keys is a match for PyPy's module dict,
+221 # which is optimized for such workloads.
+222 #
+223 # This gives a 20% benefit on the workload described at
+224 # https://bitbucket.org/pypy/pypy/issue/1871/10x-slower-than-cpython-under-coverage
+225 self.should_trace_cache = __pypy__.newdict("module")
+226 else:
+227 self.should_trace_cache = {}
+ +229 # Our active Tracers.
+230 self.tracers = []
+ +232 self._clear_data()
+ +234 def _start_tracer(self):
+235 """Start a new Tracer object, and store it in self.tracers."""
+236 tracer = self._trace_class()
+237 tracer.data = self.data
+238 tracer.trace_arcs = self.branch
+239 tracer.should_trace = self.should_trace
+240 tracer.should_trace_cache = self.should_trace_cache
+241 tracer.warn = self.warn
+ +243 if hasattr(tracer, 'concur_id_func'):
+244 tracer.concur_id_func = self.concur_id_func
+245 elif self.concur_id_func:
+246 raise CoverageException(
+247 "Can't support concurrency=%s with %s, only threads are supported" % (
+248 self.concurrency, self.tracer_name(),
+249 )
+250 )
+ +252 if hasattr(tracer, 'file_tracers'):
+253 tracer.file_tracers = self.file_tracers
+254 if hasattr(tracer, 'threading'):
+255 tracer.threading = self.threading
+256 if hasattr(tracer, 'check_include'):
+257 tracer.check_include = self.check_include
+258 if hasattr(tracer, 'should_start_context'):
+259 tracer.should_start_context = self.should_start_context
+260 tracer.switch_context = self.switch_context
+261 if hasattr(tracer, 'disable_plugin'):
+262 tracer.disable_plugin = self.disable_plugin
+ +264 fn = tracer.start()
+265 self.tracers.append(tracer)
+ +267 return fn
+ +269 # The trace function has to be set individually on each thread before
+270 # execution begins. Ironically, the only support the threading module has
+271 # for running code before the thread main is the tracing function. So we
+272 # install this as a trace function, and the first time it's called, it does
+273 # the real trace installation.
+ +275 def _installation_trace(self, frame, event, arg):
+276 """Called on new threads, installs the real tracer."""
+277 # Remove ourselves as the trace function.
+278 sys.settrace(None)
+279 # Install the real tracer.
+280 fn = self._start_tracer()
+281 # Invoke the real trace function with the current event, to be sure
+282 # not to lose an event.
+283 if fn:
+284 fn = fn(frame, event, arg)
+285 # Return the new trace function to continue tracing in this scope.
+286 return fn
+ +288 def start(self):
+289 """Start collecting trace information."""
+290 if self._collectors: 290 ↛ 293line 290 didn't jump to line 293, because the condition on line 290 was never false
+291 self._collectors[-1].pause()
+ +293 self.tracers = []
+ +295 # Check to see whether we had a fullcoverage tracer installed. If so,
+296 # get the stack frames it stashed away for us.
+297 traces0 = []
+298 fn0 = sys.gettrace()
+299 if fn0:
+300 tracer0 = getattr(fn0, '__self__', None)
+301 if tracer0:
+302 traces0 = getattr(tracer0, 'traces', [])
+ +304 try:
+305 # Install the tracer on this thread.
+306 fn = self._start_tracer()
+307 except:
+308 if self._collectors:
+309 self._collectors[-1].resume()
+310 raise
+ +312 # If _start_tracer succeeded, then we add ourselves to the global
+313 # stack of collectors.
+314 self._collectors.append(self)
+ +316 # Replay all the events from fullcoverage into the new trace function.
+317 for args in traces0: 317 ↛ 318line 317 didn't jump to line 318, because the loop on line 317 never started
+318 (frame, event, arg), lineno = args
+319 try:
+320 fn(frame, event, arg, lineno=lineno)
+321 except TypeError:
+322 raise Exception("fullcoverage must be run with the C trace function.")
+ +324 # Install our installation tracer in threading, to jump-start other
+325 # threads.
+326 if self.threading: 326 ↛ exitline 326 didn't return from function 'start', because the condition on line 326 was never false
+327 self.threading.settrace(self._installation_trace)
+ +329 def stop(self):
+330 """Stop collecting trace information."""
+331 assert self._collectors
+332 if self._collectors[-1] is not self: 332 ↛ 333line 332 didn't jump to line 333, because the condition on line 332 was never true
+333 print("self._collectors:")
+334 for c in self._collectors:
+335 print(" {!r}\n{}".format(c, c.origin))
+336 assert self._collectors[-1] is self, (
+337 "Expected current collector to be %r, but it's %r" % (self, self._collectors[-1])
+338 )
+ +340 self.pause()
+ +342 # Remove this Collector from the stack, and resume the one underneath
+343 # (if any).
+344 self._collectors.pop()
+345 if self._collectors:
+346 self._collectors[-1].resume()
+ +348 def pause(self):
+349 """Pause tracing, but be prepared to `resume`."""
+350 for tracer in self.tracers: 350 ↛ 357line 350 didn't jump to line 357, because the loop on line 350 didn't complete
+351 tracer.stop()
+352 stats = tracer.get_stats()
+353 if stats: 353 ↛ 354line 353 didn't jump to line 354, because the condition on line 353 was never true
+354 print("\nCoverage.py tracer stats:")
+355 for k in sorted(stats.keys()):
+356 print("%20s: %s" % (k, stats[k]))
+357 if self.threading:
+358 self.threading.settrace(None)
+ +360 def resume(self):
+361 """Resume tracing after a `pause`."""
+362 for tracer in self.tracers:
+363 tracer.start()
+364 if self.threading: 364 ↛ 367line 364 didn't jump to line 367, because the condition on line 364 was never false
+365 self.threading.settrace(self._installation_trace)
+366 else:
+367 self._start_tracer()
+ +369 def _activity(self):
+370 """Has any activity been traced?
+ +372 Returns a boolean, True if any trace function was invoked.
+ +374 """
+375 return any(tracer.activity() for tracer in self.tracers)
+ +377 def switch_context(self, new_context):
+378 """Switch to a new dynamic context."""
+379 self.flush_data()
+380 if self.static_context:
+381 context = self.static_context
+382 if new_context:
+383 context += "|" + new_context
+384 else:
+385 context = new_context
+386 self.covdata.set_context(context)
+ +388 def disable_plugin(self, disposition):
+389 """Disable the plugin mentioned in `disposition`."""
+390 file_tracer = disposition.file_tracer
+391 plugin = file_tracer._coverage_plugin
+392 plugin_name = plugin._coverage_plugin_name
+393 self.warn("Disabling plug-in {!r} due to previous exception".format(plugin_name))
+394 plugin._coverage_enabled = False
+395 disposition.trace = False
+ +397 def cached_mapped_file(self, filename):
+398 """A locally cached version of file names mapped through file_mapper."""
+399 key = (type(filename), filename)
+400 try:
+401 return self.mapped_file_cache[key]
+402 except KeyError:
+403 return self.mapped_file_cache.setdefault(key, self.file_mapper(filename))
+ +405 def mapped_file_dict(self, d):
+406 """Return a dict like d, but with keys modified by file_mapper."""
+407 # The call to litems() ensures that the GIL protects the dictionary
+408 # iterator against concurrent modifications by tracers running
+409 # in other threads. We try three times in case of concurrent
+410 # access, hoping to get a clean copy.
+411 runtime_err = None
+412 for _ in range(3): 412 ↛ 420line 412 didn't jump to line 420, because the loop on line 412 didn't complete
+413 try:
+414 items = litems(d)
+415 except RuntimeError as ex:
+416 runtime_err = ex
+417 else:
+418 break
+419 else:
+420 raise runtime_err
+ +422 return dict((self.cached_mapped_file(k), v) for k, v in items if v)
+ +424 def plugin_was_disabled(self, plugin):
+425 """Record that `plugin` was disabled during the run."""
+426 self.disabled_plugins.add(plugin._coverage_plugin_name)
+ +428 def flush_data(self):
+429 """Save the collected data to our associated `CoverageData`.
+ +431 Data may have also been saved along the way. This forces the
+432 last of the data to be saved.
+ +434 Returns True if there was data to save, False if not.
+435 """
+436 if not self._activity():
+437 return False
+ +439 if self.branch:
+440 self.covdata.add_arcs(self.mapped_file_dict(self.data))
+441 else:
+442 self.covdata.add_lines(self.mapped_file_dict(self.data))
+ +444 file_tracers = {
+445 k: v for k, v in self.file_tracers.items()
+446 if v not in self.disabled_plugins
+447 }
+448 self.covdata.add_file_tracers(self.mapped_file_dict(file_tracers))
+ +450 self._clear_data()
+451 return True
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Config file for coverage.py"""
+ +6import collections
+7import copy
+8import os
+9import os.path
+10import re
+ +12from coverage import env
+13from coverage.backward import configparser, iitems, string_class
+14from coverage.misc import contract, CoverageException, isolate_module
+15from coverage.misc import substitute_variables
+ +17from coverage.tomlconfig import TomlConfigParser, TomlDecodeError
+ +19os = isolate_module(os)
+ + +22class HandyConfigParser(configparser.RawConfigParser):
+23 """Our specialization of ConfigParser."""
+ +25 def __init__(self, our_file):
+26 """Create the HandyConfigParser.
+ +28 `our_file` is True if this config file is specifically for coverage,
+29 False if we are examining another config file (tox.ini, setup.cfg)
+30 for possible settings.
+31 """
+ +33 configparser.RawConfigParser.__init__(self)
+34 self.section_prefixes = ["coverage:"]
+35 if our_file:
+36 self.section_prefixes.append("")
+ +38 def read(self, filenames, encoding_unused=None):
+39 """Read a file name as UTF-8 configuration data."""
+40 kwargs = {}
+41 if env.PYVERSION >= (3, 2):
+42 kwargs['encoding'] = "utf-8"
+43 return configparser.RawConfigParser.read(self, filenames, **kwargs)
+ +45 def has_option(self, section, option):
+46 for section_prefix in self.section_prefixes:
+47 real_section = section_prefix + section
+48 has = configparser.RawConfigParser.has_option(self, real_section, option)
+49 if has:
+50 return has
+51 return False
+ +53 def has_section(self, section):
+54 for section_prefix in self.section_prefixes:
+55 real_section = section_prefix + section
+56 has = configparser.RawConfigParser.has_section(self, real_section)
+57 if has:
+58 return real_section
+59 return False
+ +61 def options(self, section):
+62 for section_prefix in self.section_prefixes:
+63 real_section = section_prefix + section
+64 if configparser.RawConfigParser.has_section(self, real_section):
+65 return configparser.RawConfigParser.options(self, real_section)
+66 raise configparser.NoSectionError(section)
+ +68 def get_section(self, section):
+69 """Get the contents of a section, as a dictionary."""
+70 d = {}
+71 for opt in self.options(section):
+72 d[opt] = self.get(section, opt)
+73 return d
+ +75 def get(self, section, option, *args, **kwargs):
+76 """Get a value, replacing environment variables also.
+ +78 The arguments are the same as `RawConfigParser.get`, but in the found
+79 value, ``$WORD`` or ``${WORD}`` are replaced by the value of the
+80 environment variable ``WORD``.
+ +82 Returns the finished value.
+ +84 """
+85 for section_prefix in self.section_prefixes:
+86 real_section = section_prefix + section
+87 if configparser.RawConfigParser.has_option(self, real_section, option):
+88 break
+89 else:
+90 raise configparser.NoOptionError(option, section)
+ +92 v = configparser.RawConfigParser.get(self, real_section, option, *args, **kwargs)
+93 v = substitute_variables(v, os.environ)
+94 return v
+ +96 def getlist(self, section, option):
+97 """Read a list of strings.
+ +99 The value of `section` and `option` is treated as a comma- and newline-
+100 separated list of strings. Each value is stripped of whitespace.
+ +102 Returns the list of strings.
+ +104 """
+105 value_list = self.get(section, option)
+106 values = []
+107 for value_line in value_list.split('\n'):
+108 for value in value_line.split(','):
+109 value = value.strip()
+110 if value:
+111 values.append(value)
+112 return values
+ +114 def getregexlist(self, section, option):
+115 """Read a list of full-line regexes.
+ +117 The value of `section` and `option` is treated as a newline-separated
+118 list of regexes. Each value is stripped of whitespace.
+ +120 Returns the list of strings.
+ +122 """
+123 line_list = self.get(section, option)
+124 value_list = []
+125 for value in line_list.splitlines():
+126 value = value.strip()
+127 try:
+128 re.compile(value)
+129 except re.error as e:
+130 raise CoverageException(
+131 "Invalid [%s].%s value %r: %s" % (section, option, value, e)
+132 )
+133 if value:
+134 value_list.append(value)
+135 return value_list
+ + +138# The default line exclusion regexes.
+139DEFAULT_EXCLUDE = [
+140 r'#\s*(pragma|PRAGMA)[:\s]?\s*(no|NO)\s*(cover|COVER)',
+141]
+ +143# The default partial branch regexes, to be modified by the user.
+144DEFAULT_PARTIAL = [
+145 r'#\s*(pragma|PRAGMA)[:\s]?\s*(no|NO)\s*(branch|BRANCH)',
+146]
+ +148# The default partial branch regexes, based on Python semantics.
+149# These are any Python branching constructs that can't actually execute all
+150# their branches.
+151DEFAULT_PARTIAL_ALWAYS = [
+152 'while (True|1|False|0):',
+153 'if (True|1|False|0):',
+154]
+ + +157class CoverageConfig(object):
+158 """Coverage.py configuration.
+ +160 The attributes of this class are the various settings that control the
+161 operation of coverage.py.
+ +163 """
+164 # pylint: disable=too-many-instance-attributes
+ +166 def __init__(self):
+167 """Initialize the configuration attributes to their defaults."""
+168 # Metadata about the config.
+169 # We tried to read these config files.
+170 self.attempted_config_files = []
+171 # We did read these config files, but maybe didn't find any content for us.
+172 self.config_files_read = []
+173 # The file that gave us our configuration.
+174 self.config_file = None
+175 self._config_contents = None
+ +177 # Defaults for [run] and [report]
+178 self._include = None
+179 self._omit = None
+ +181 # Defaults for [run]
+182 self.branch = False
+183 self.command_line = None
+184 self.concurrency = None
+185 self.context = None
+186 self.cover_pylib = False
+187 self.data_file = ".coverage"
+188 self.debug = []
+189 self.disable_warnings = []
+190 self.dynamic_context = None
+191 self.note = None
+192 self.parallel = False
+193 self.plugins = []
+194 self.relative_files = False
+195 self.run_include = None
+196 self.run_omit = None
+197 self.source = None
+198 self.source_pkgs = []
+199 self.timid = False
+200 self._crash = None
+ +202 # Defaults for [report]
+203 self.exclude_list = DEFAULT_EXCLUDE[:]
+204 self.fail_under = 0.0
+205 self.ignore_errors = False
+206 self.report_include = None
+207 self.report_omit = None
+208 self.partial_always_list = DEFAULT_PARTIAL_ALWAYS[:]
+209 self.partial_list = DEFAULT_PARTIAL[:]
+210 self.precision = 0
+211 self.report_contexts = None
+212 self.show_missing = False
+213 self.skip_covered = False
+214 self.skip_empty = False
+215 self.sort = None
+ +217 # Defaults for [html]
+218 self.extra_css = None
+219 self.html_dir = "htmlcov"
+220 self.html_skip_covered = None
+221 self.html_skip_empty = None
+222 self.html_title = "Coverage report"
+223 self.show_contexts = False
+ +225 # Defaults for [xml]
+226 self.xml_output = "coverage.xml"
+227 self.xml_package_depth = 99
+ +229 # Defaults for [json]
+230 self.json_output = "coverage.json"
+231 self.json_pretty_print = False
+232 self.json_show_contexts = False
+ +234 # Defaults for [paths]
+235 self.paths = collections.OrderedDict()
+ +237 # Options for plugins
+238 self.plugin_options = {}
+ +240 MUST_BE_LIST = [
+241 "debug", "concurrency", "plugins",
+242 "report_omit", "report_include",
+243 "run_omit", "run_include",
+244 ]
+ +246 def from_args(self, **kwargs):
+247 """Read config values from `kwargs`."""
+248 for k, v in iitems(kwargs):
+249 if v is not None:
+250 if k in self.MUST_BE_LIST and isinstance(v, string_class):
+251 v = [v]
+252 setattr(self, k, v)
+ +254 @contract(filename=str)
+255 def from_file(self, filename, our_file):
+256 """Read configuration from a .rc file.
+ +258 `filename` is a file name to read.
+ +260 `our_file` is True if this config file is specifically for coverage,
+261 False if we are examining another config file (tox.ini, setup.cfg)
+262 for possible settings.
+ +264 Returns True or False, whether the file could be read, and it had some
+265 coverage.py settings in it.
+ +267 """
+268 _, ext = os.path.splitext(filename)
+269 if ext == '.toml':
+270 cp = TomlConfigParser(our_file)
+271 else:
+272 cp = HandyConfigParser(our_file)
+ +274 self.attempted_config_files.append(filename)
+ +276 try:
+277 files_read = cp.read(filename)
+278 except (configparser.Error, TomlDecodeError) as err:
+279 raise CoverageException("Couldn't read config file %s: %s" % (filename, err))
+280 if not files_read:
+281 return False
+ +283 self.config_files_read.extend(map(os.path.abspath, files_read))
+ +285 any_set = False
+286 try:
+287 for option_spec in self.CONFIG_FILE_OPTIONS:
+288 was_set = self._set_attr_from_config_option(cp, *option_spec)
+289 if was_set:
+290 any_set = True
+291 except ValueError as err:
+292 raise CoverageException("Couldn't read config file %s: %s" % (filename, err))
+ +294 # Check that there are no unrecognized options.
+295 all_options = collections.defaultdict(set)
+296 for option_spec in self.CONFIG_FILE_OPTIONS:
+297 section, option = option_spec[1].split(":")
+298 all_options[section].add(option)
+ +300 for section, options in iitems(all_options):
+301 real_section = cp.has_section(section)
+302 if real_section:
+303 for unknown in set(cp.options(section)) - options:
+304 raise CoverageException(
+305 "Unrecognized option '[%s] %s=' in config file %s" % (
+306 real_section, unknown, filename
+307 )
+308 )
+ +310 # [paths] is special
+311 if cp.has_section('paths'):
+312 for option in cp.options('paths'):
+313 self.paths[option] = cp.getlist('paths', option)
+314 any_set = True
+ +316 # plugins can have options
+317 for plugin in self.plugins:
+318 if cp.has_section(plugin):
+319 self.plugin_options[plugin] = cp.get_section(plugin)
+320 any_set = True
+ +322 # Was this file used as a config file? If it's specifically our file,
+323 # then it was used. If we're piggybacking on someone else's file,
+324 # then it was only used if we found some settings in it.
+325 if our_file:
+326 used = True
+327 else:
+328 used = any_set
+ +330 if used:
+331 self.config_file = os.path.abspath(filename)
+332 with open(filename, "rb") as f:
+333 self._config_contents = f.read()
+ +335 return used
+ +337 def copy(self):
+338 """Return a copy of the configuration."""
+339 return copy.deepcopy(self)
+ +341 CONFIG_FILE_OPTIONS = [
+342 # These are *args for _set_attr_from_config_option:
+343 # (attr, where, type_="")
+344 #
+345 # attr is the attribute to set on the CoverageConfig object.
+346 # where is the section:name to read from the configuration file.
+347 # type_ is the optional type to apply, by using .getTYPE to read the
+348 # configuration value from the file.
+ +350 # [run]
+351 ('branch', 'run:branch', 'boolean'),
+352 ('command_line', 'run:command_line'),
+353 ('concurrency', 'run:concurrency', 'list'),
+354 ('context', 'run:context'),
+355 ('cover_pylib', 'run:cover_pylib', 'boolean'),
+356 ('data_file', 'run:data_file'),
+357 ('debug', 'run:debug', 'list'),
+358 ('disable_warnings', 'run:disable_warnings', 'list'),
+359 ('dynamic_context', 'run:dynamic_context'),
+360 ('note', 'run:note'),
+361 ('parallel', 'run:parallel', 'boolean'),
+362 ('plugins', 'run:plugins', 'list'),
+363 ('relative_files', 'run:relative_files', 'boolean'),
+364 ('run_include', 'run:include', 'list'),
+365 ('run_omit', 'run:omit', 'list'),
+366 ('source', 'run:source', 'list'),
+367 ('source_pkgs', 'run:source_pkgs', 'list'),
+368 ('timid', 'run:timid', 'boolean'),
+369 ('_crash', 'run:_crash'),
+ +371 # [report]
+372 ('exclude_list', 'report:exclude_lines', 'regexlist'),
+373 ('fail_under', 'report:fail_under', 'float'),
+374 ('ignore_errors', 'report:ignore_errors', 'boolean'),
+375 ('partial_always_list', 'report:partial_branches_always', 'regexlist'),
+376 ('partial_list', 'report:partial_branches', 'regexlist'),
+377 ('precision', 'report:precision', 'int'),
+378 ('report_contexts', 'report:contexts', 'list'),
+379 ('report_include', 'report:include', 'list'),
+380 ('report_omit', 'report:omit', 'list'),
+381 ('show_missing', 'report:show_missing', 'boolean'),
+382 ('skip_covered', 'report:skip_covered', 'boolean'),
+383 ('skip_empty', 'report:skip_empty', 'boolean'),
+384 ('sort', 'report:sort'),
+ +386 # [html]
+387 ('extra_css', 'html:extra_css'),
+388 ('html_dir', 'html:directory'),
+389 ('html_skip_covered', 'html:skip_covered', 'boolean'),
+390 ('html_skip_empty', 'html:skip_empty', 'boolean'),
+391 ('html_title', 'html:title'),
+392 ('show_contexts', 'html:show_contexts', 'boolean'),
+ +394 # [xml]
+395 ('xml_output', 'xml:output'),
+396 ('xml_package_depth', 'xml:package_depth', 'int'),
+ +398 # [json]
+399 ('json_output', 'json:output'),
+400 ('json_pretty_print', 'json:pretty_print', 'boolean'),
+401 ('json_show_contexts', 'json:show_contexts', 'boolean'),
+402 ]
+ +404 def _set_attr_from_config_option(self, cp, attr, where, type_=''):
+405 """Set an attribute on self if it exists in the ConfigParser.
+ +407 Returns True if the attribute was set.
+ +409 """
+410 section, option = where.split(":")
+411 if cp.has_option(section, option):
+412 method = getattr(cp, 'get' + type_)
+413 setattr(self, attr, method(section, option))
+414 return True
+415 return False
+ +417 def get_plugin_options(self, plugin):
+418 """Get a dictionary of options for the plugin named `plugin`."""
+419 return self.plugin_options.get(plugin, {})
+ +421 def set_option(self, option_name, value):
+422 """Set an option in the configuration.
+ +424 `option_name` is a colon-separated string indicating the section and
+425 option name. For example, the ``branch`` option in the ``[run]``
+426 section of the config file would be indicated with `"run:branch"`.
+ +428 `value` is the new value for the option.
+ +430 """
+431 # Special-cased options.
+432 if option_name == "paths":
+433 self.paths = value
+434 return
+ +436 # Check all the hard-coded options.
+437 for option_spec in self.CONFIG_FILE_OPTIONS:
+438 attr, where = option_spec[:2]
+439 if where == option_name:
+440 setattr(self, attr, value)
+441 return
+ +443 # See if it's a plugin option.
+444 plugin_name, _, key = option_name.partition(":")
+445 if key and plugin_name in self.plugins:
+446 self.plugin_options.setdefault(plugin_name, {})[key] = value
+447 return
+ +449 # If we get here, we didn't find the option.
+450 raise CoverageException("No such option: %r" % option_name)
+ +452 def get_option(self, option_name):
+453 """Get an option from the configuration.
+ +455 `option_name` is a colon-separated string indicating the section and
+456 option name. For example, the ``branch`` option in the ``[run]``
+457 section of the config file would be indicated with `"run:branch"`.
+ +459 Returns the value of the option.
+ +461 """
+462 # Special-cased options.
+463 if option_name == "paths":
+464 return self.paths
+ +466 # Check all the hard-coded options.
+467 for option_spec in self.CONFIG_FILE_OPTIONS:
+468 attr, where = option_spec[:2]
+469 if where == option_name:
+470 return getattr(self, attr)
+ +472 # See if it's a plugin option.
+473 plugin_name, _, key = option_name.partition(":")
+474 if key and plugin_name in self.plugins:
+475 return self.plugin_options.get(plugin_name, {}).get(key)
+ +477 # If we get here, we didn't find the option.
+478 raise CoverageException("No such option: %r" % option_name)
+ +480 def post_process_file(self, path):
+481 """Make final adjustments to a file path to make it usable."""
+482 return os.path.expanduser(path)
+ +484 def post_process(self):
+485 """Make final adjustments to settings to make them usable."""
+486 self.data_file = self.post_process_file(self.data_file)
+487 self.html_dir = self.post_process_file(self.html_dir)
+488 self.xml_output = self.post_process_file(self.xml_output)
+489 self.paths = collections.OrderedDict(
+490 (k, [self.post_process_file(f) for f in v])
+491 for k, v in self.paths.items()
+492 )
+ + +495def config_files_to_try(config_file):
+496 """What config files should we try to read?
+ +498 Returns a list of tuples:
+499 (filename, is_our_file, was_file_specified)
+500 """
+ +502 # Some API users were specifying ".coveragerc" to mean the same as
+503 # True, so make it so.
+504 if config_file == ".coveragerc":
+505 config_file = True
+506 specified_file = (config_file is not True)
+507 if not specified_file:
+508 # No file was specified. Check COVERAGE_RCFILE.
+509 config_file = os.environ.get('COVERAGE_RCFILE')
+510 if config_file:
+511 specified_file = True
+512 if not specified_file:
+513 # Still no file specified. Default to .coveragerc
+514 config_file = ".coveragerc"
+515 files_to_try = [
+516 (config_file, True, specified_file),
+517 ("setup.cfg", False, False),
+518 ("tox.ini", False, False),
+519 ("pyproject.toml", False, False),
+520 ]
+521 return files_to_try
+ + +524def read_coverage_config(config_file, **kwargs):
+525 """Read the coverage.py configuration.
+ +527 Arguments:
+528 config_file: a boolean or string, see the `Coverage` class for the
+529 tricky details.
+530 all others: keyword arguments from the `Coverage` class, used for
+531 setting values in the configuration.
+ +533 Returns:
+534 config:
+535 config is a CoverageConfig object read from the appropriate
+536 configuration file.
+ +538 """
+539 # Build the configuration from a number of sources:
+540 # 1) defaults:
+541 config = CoverageConfig()
+ +543 # 2) from a file:
+544 if config_file:
+545 files_to_try = config_files_to_try(config_file)
+ +547 for fname, our_file, specified_file in files_to_try:
+548 config_read = config.from_file(fname, our_file=our_file)
+549 if config_read:
+550 break
+551 if specified_file:
+552 raise CoverageException("Couldn't read '%s' as a config file" % fname)
+ +554 # $set_env.py: COVERAGE_DEBUG - Options for --debug.
+555 # 3) from environment variables:
+556 env_data_file = os.environ.get('COVERAGE_FILE')
+557 if env_data_file:
+558 config.data_file = env_data_file
+559 debugs = os.environ.get('COVERAGE_DEBUG')
+560 if debugs:
+561 config.debug.extend(d.strip() for d in debugs.split(","))
+ +563 # 4) from constructor arguments:
+564 config.from_args(**kwargs)
+ +566 # Once all the config has been collected, there's a little post-processing
+567 # to do.
+568 config.post_process()
+ +570 return config
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Determine contexts for coverage.py"""
+ + +7def combine_context_switchers(context_switchers):
+8 """Create a single context switcher from multiple switchers.
+ +10 `context_switchers` is a list of functions that take a frame as an
+11 argument and return a string to use as the new context label.
+ +13 Returns a function that composites `context_switchers` functions, or None
+14 if `context_switchers` is an empty list.
+ +16 When invoked, the combined switcher calls `context_switchers` one-by-one
+17 until a string is returned. The combined switcher returns None if all
+18 `context_switchers` return None.
+19 """
+20 if not context_switchers:
+21 return None
+ +23 if len(context_switchers) == 1:
+24 return context_switchers[0]
+ +26 def should_start_context(frame):
+27 """The combiner for multiple context switchers."""
+28 for switcher in context_switchers:
+29 new_context = switcher(frame)
+30 if new_context is not None:
+31 return new_context
+32 return None
+ +34 return should_start_context
+ + +37def should_start_context_test_function(frame):
+38 """Is this frame calling a test_* function?"""
+39 co_name = frame.f_code.co_name
+40 if co_name.startswith("test") or co_name == "runTest":
+41 return qualname_from_frame(frame)
+42 return None
+ + +45def qualname_from_frame(frame):
+46 """Get a qualified name for the code running in `frame`."""
+47 co = frame.f_code
+48 fname = co.co_name
+49 method = None
+50 if co.co_argcount and co.co_varnames[0] == "self":
+51 self = frame.f_locals["self"]
+52 method = getattr(self, fname, None)
+ +54 if method is None:
+55 func = frame.f_globals.get(fname)
+56 if func is None:
+57 return None
+58 return func.__module__ + '.' + fname
+ +60 func = getattr(method, '__func__', None)
+61 if func is None:
+62 cls = self.__class__
+63 return cls.__module__ + '.' + cls.__name__ + "." + fname
+ +65 if hasattr(func, '__qualname__'):
+66 qname = func.__module__ + '.' + func.__qualname__
+67 else:
+68 for cls in getattr(self.__class__, '__mro__', ()):
+69 f = cls.__dict__.get(fname, None)
+70 if f is None:
+71 continue
+72 if f is func: 72 ↛ 68line 72 didn't jump to line 68, because the condition on line 72 was never false
+73 qname = cls.__module__ + '.' + cls.__name__ + "." + fname
+74 break
+75 else:
+76 # Support for old-style classes.
+77 def mro(bases):
+78 for base in bases:
+79 f = base.__dict__.get(fname, None)
+80 if f is func:
+81 return base.__module__ + '.' + base.__name__ + "." + fname
+82 for base in bases: 82 ↛ 86line 82 didn't jump to line 86, because the loop on line 82 didn't complete
+83 qname = mro(base.__bases__)
+84 if qname is not None: 84 ↛ 82line 84 didn't jump to line 82, because the condition on line 84 was never false
+85 return qname
+86 return None
+87 qname = mro([self.__class__])
+88 if qname is None: 88 ↛ 89line 88 didn't jump to line 89, because the condition on line 88 was never true
+89 qname = func.__module__ + '.' + fname
+ +91 return qname
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Core control stuff for coverage.py."""
+ +6import atexit
+7import collections
+8import contextlib
+9import os
+10import os.path
+11import platform
+12import sys
+13import time
+ +15from coverage import env
+16from coverage.annotate import AnnotateReporter
+17from coverage.backward import string_class, iitems
+18from coverage.collector import Collector, CTracer
+19from coverage.config import read_coverage_config
+20from coverage.context import should_start_context_test_function, combine_context_switchers
+21from coverage.data import CoverageData, combine_parallel_data
+22from coverage.debug import DebugControl, short_stack, write_formatted_info
+23from coverage.disposition import disposition_debug_msg
+24from coverage.files import PathAliases, abs_file, relative_filename, set_relative_directory
+25from coverage.html import HtmlReporter
+26from coverage.inorout import InOrOut
+27from coverage.jsonreport import JsonReporter
+28from coverage.misc import CoverageException, bool_or_none, join_regex
+29from coverage.misc import DefaultValue, ensure_dir_for_file, isolate_module
+30from coverage.plugin import FileReporter
+31from coverage.plugin_support import Plugins
+32from coverage.python import PythonFileReporter
+33from coverage.report import render_report
+34from coverage.results import Analysis, Numbers
+35from coverage.summary import SummaryReporter
+36from coverage.xmlreport import XmlReporter
+ +38try:
+39 from coverage.multiproc import patch_multiprocessing
+40except ImportError: # pragma: only jython
+41 # Jython has no multiprocessing module.
+42 patch_multiprocessing = None
+ +44os = isolate_module(os)
+ +46@contextlib.contextmanager
+47def override_config(cov, **kwargs):
+48 """Temporarily tweak the configuration of `cov`.
+ +50 The arguments are applied to `cov.config` with the `from_args` method.
+51 At the end of the with-statement, the old configuration is restored.
+52 """
+53 original_config = cov.config
+54 cov.config = cov.config.copy()
+55 try:
+56 cov.config.from_args(**kwargs)
+57 yield
+58 finally:
+59 cov.config = original_config
+ + +62_DEFAULT_DATAFILE = DefaultValue("MISSING")
+ +64class Coverage(object):
+65 """Programmatic access to coverage.py.
+ +67 To use::
+ +69 from coverage import Coverage
+ +71 cov = Coverage()
+72 cov.start()
+73 #.. call your code ..
+74 cov.stop()
+75 cov.html_report(directory='covhtml')
+ +77 Note: in keeping with Python custom, names starting with underscore are
+78 not part of the public API. They might stop working at any point. Please
+79 limit yourself to documented methods to avoid problems.
+ +81 """
+ +83 # The stack of started Coverage instances.
+84 _instances = []
+ +86 @classmethod
+87 def current(cls):
+88 """Get the latest started `Coverage` instance, if any.
+ +90 Returns: a `Coverage` instance, or None.
+ +92 .. versionadded:: 5.0
+ +94 """
+95 if cls._instances: 95 ↛ 98line 95 didn't jump to line 98, because the condition on line 95 was never false
+96 return cls._instances[-1]
+97 else:
+98 return None
+ +100 def __init__(
+101 self, data_file=_DEFAULT_DATAFILE, data_suffix=None, cover_pylib=None,
+102 auto_data=False, timid=None, branch=None, config_file=True,
+103 source=None, source_pkgs=None, omit=None, include=None, debug=None,
+104 concurrency=None, check_preimported=False, context=None,
+105 ): # pylint: disable=too-many-arguments
+106 """
+107 Many of these arguments duplicate and override values that can be
+108 provided in a configuration file. Parameters that are missing here
+109 will use values from the config file.
+ +111 `data_file` is the base name of the data file to use. The config value
+112 defaults to ".coverage". None can be provided to prevent writing a data
+113 file. `data_suffix` is appended (with a dot) to `data_file` to create
+114 the final file name. If `data_suffix` is simply True, then a suffix is
+115 created with the machine and process identity included.
+ +117 `cover_pylib` is a boolean determining whether Python code installed
+118 with the Python interpreter is measured. This includes the Python
+119 standard library and any packages installed with the interpreter.
+ +121 If `auto_data` is true, then any existing data file will be read when
+122 coverage measurement starts, and data will be saved automatically when
+123 measurement stops.
+ +125 If `timid` is true, then a slower and simpler trace function will be
+126 used. This is important for some environments where manipulation of
+127 tracing functions breaks the faster trace function.
+ +129 If `branch` is true, then branch coverage will be measured in addition
+130 to the usual statement coverage.
+ +132 `config_file` determines what configuration file to read:
+ +134 * If it is ".coveragerc", it is interpreted as if it were True,
+135 for backward compatibility.
+ +137 * If it is a string, it is the name of the file to read. If the
+138 file can't be read, it is an error.
+ +140 * If it is True, then a few standard files names are tried
+141 (".coveragerc", "setup.cfg", "tox.ini"). It is not an error for
+142 these files to not be found.
+ +144 * If it is False, then no configuration file is read.
+ +146 `source` is a list of file paths or package names. Only code located
+147 in the trees indicated by the file paths or package names will be
+148 measured.
+ +150 `source_pkgs` is a list of package names. It works the same as
+151 `source`, but can be used to name packages where the name can also be
+152 interpreted as a file path.
+ +154 `include` and `omit` are lists of file name patterns. Files that match
+155 `include` will be measured, files that match `omit` will not. Each
+156 will also accept a single string argument.
+ +158 `debug` is a list of strings indicating what debugging information is
+159 desired.
+ +161 `concurrency` is a string indicating the concurrency library being used
+162 in the measured code. Without this, coverage.py will get incorrect
+163 results if these libraries are in use. Valid strings are "greenlet",
+164 "eventlet", "gevent", "multiprocessing", or "thread" (the default).
+165 This can also be a list of these strings.
+ +167 If `check_preimported` is true, then when coverage is started, the
+168 already-imported files will be checked to see if they should be
+169 measured by coverage. Importing measured files before coverage is
+170 started can mean that code is missed.
+ +172 `context` is a string to use as the :ref:`static context
+173 <static_contexts>` label for collected data.
+ +175 .. versionadded:: 4.0
+176 The `concurrency` parameter.
+ +178 .. versionadded:: 4.2
+179 The `concurrency` parameter can now be a list of strings.
+ +181 .. versionadded:: 5.0
+182 The `check_preimported` and `context` parameters.
+ +184 .. versionadded:: 5.3
+185 The `source_pkgs` parameter.
+ +187 """
+188 # data_file=None means no disk file at all. data_file missing means
+189 # use the value from the config file.
+190 self._no_disk = data_file is None
+191 if data_file is _DEFAULT_DATAFILE:
+192 data_file = None
+ +194 # Build our configuration from a number of sources.
+195 self.config = read_coverage_config(
+196 config_file=config_file,
+197 data_file=data_file, cover_pylib=cover_pylib, timid=timid,
+198 branch=branch, parallel=bool_or_none(data_suffix),
+199 source=source, source_pkgs=source_pkgs, run_omit=omit, run_include=include, debug=debug,
+200 report_omit=omit, report_include=include,
+201 concurrency=concurrency, context=context,
+202 )
+ +204 # This is injectable by tests.
+205 self._debug_file = None
+ +207 self._auto_load = self._auto_save = auto_data
+208 self._data_suffix_specified = data_suffix
+ +210 # Is it ok for no data to be collected?
+211 self._warn_no_data = True
+212 self._warn_unimported_source = True
+213 self._warn_preimported_source = check_preimported
+214 self._no_warn_slugs = None
+ +216 # A record of all the warnings that have been issued.
+217 self._warnings = []
+ +219 # Other instance attributes, set later.
+220 self._data = self._collector = None
+221 self._plugins = None
+222 self._inorout = None
+223 self._data_suffix = self._run_suffix = None
+224 self._exclude_re = None
+225 self._debug = None
+226 self._file_mapper = None
+ +228 # State machine variables:
+229 # Have we initialized everything?
+230 self._inited = False
+231 self._inited_for_start = False
+232 # Have we started collecting and not stopped it?
+233 self._started = False
+234 # Should we write the debug output?
+235 self._should_write_debug = True
+ +237 # If we have sub-process measurement happening automatically, then we
+238 # want any explicit creation of a Coverage object to mean, this process
+239 # is already coverage-aware, so don't auto-measure it. By now, the
+240 # auto-creation of a Coverage object has already happened. But we can
+241 # find it and tell it not to save its data.
+242 if not env.METACOV:
+243 _prevent_sub_process_measurement()
+ +245 def _init(self):
+246 """Set all the initial state.
+ +248 This is called by the public methods to initialize state. This lets us
+249 construct a :class:`Coverage` object, then tweak its state before this
+250 function is called.
+ +252 """
+253 if self._inited:
+254 return
+ +256 self._inited = True
+ +258 # Create and configure the debugging controller. COVERAGE_DEBUG_FILE
+259 # is an environment variable, the name of a file to append debug logs
+260 # to.
+261 self._debug = DebugControl(self.config.debug, self._debug_file)
+ +263 if "multiprocessing" in (self.config.concurrency or ()):
+264 # Multi-processing uses parallel for the subprocesses, so also use
+265 # it for the main process.
+266 self.config.parallel = True
+ +268 # _exclude_re is a dict that maps exclusion list names to compiled regexes.
+269 self._exclude_re = {}
+ +271 set_relative_directory()
+272 self._file_mapper = relative_filename if self.config.relative_files else abs_file
+ +274 # Load plugins
+275 self._plugins = Plugins.load_plugins(self.config.plugins, self.config, self._debug)
+ +277 # Run configuring plugins.
+278 for plugin in self._plugins.configurers:
+279 # We need an object with set_option and get_option. Either self or
+280 # self.config will do. Choosing randomly stops people from doing
+281 # other things with those objects, against the public API. Yes,
+282 # this is a bit childish. :)
+283 plugin.configure([self, self.config][int(time.time()) % 2])
+ +285 def _post_init(self):
+286 """Stuff to do after everything is initialized."""
+287 if self._should_write_debug:
+288 self._should_write_debug = False
+289 self._write_startup_debug()
+ +291 # '[run] _crash' will raise an exception if the value is close by in
+292 # the call stack, for testing error handling.
+293 if self.config._crash and self.config._crash in short_stack(limit=4):
+294 raise Exception("Crashing because called by {}".format(self.config._crash))
+ +296 def _write_startup_debug(self):
+297 """Write out debug info at startup if needed."""
+298 wrote_any = False
+299 with self._debug.without_callers():
+300 if self._debug.should('config'):
+301 config_info = sorted(self.config.__dict__.items())
+302 config_info = [(k, v) for k, v in config_info if not k.startswith('_')]
+303 write_formatted_info(self._debug, "config", config_info)
+304 wrote_any = True
+ +306 if self._debug.should('sys'):
+307 write_formatted_info(self._debug, "sys", self.sys_info())
+308 for plugin in self._plugins:
+309 header = "sys: " + plugin._coverage_plugin_name
+310 info = plugin.sys_info()
+311 write_formatted_info(self._debug, header, info)
+312 wrote_any = True
+ +314 if wrote_any:
+315 write_formatted_info(self._debug, "end", ())
+ +317 def _should_trace(self, filename, frame):
+318 """Decide whether to trace execution in `filename`.
+ +320 Calls `_should_trace_internal`, and returns the FileDisposition.
+ +322 """
+323 disp = self._inorout.should_trace(filename, frame)
+324 if self._debug.should('trace'):
+325 self._debug.write(disposition_debug_msg(disp))
+326 return disp
+ +328 def _check_include_omit_etc(self, filename, frame):
+329 """Check a file name against the include/omit/etc, rules, verbosely.
+ +331 Returns a boolean: True if the file should be traced, False if not.
+ +333 """
+334 reason = self._inorout.check_include_omit_etc(filename, frame)
+335 if self._debug.should('trace'):
+336 if not reason:
+337 msg = "Including %r" % (filename,)
+338 else:
+339 msg = "Not including %r: %s" % (filename, reason)
+340 self._debug.write(msg)
+ +342 return not reason
+ +344 def _warn(self, msg, slug=None, once=False):
+345 """Use `msg` as a warning.
+ +347 For warning suppression, use `slug` as the shorthand.
+ +349 If `once` is true, only show this warning once (determined by the
+350 slug.)
+ +352 """
+353 if self._no_warn_slugs is None:
+354 self._no_warn_slugs = list(self.config.disable_warnings)
+ +356 if slug in self._no_warn_slugs:
+357 # Don't issue the warning
+358 return
+ +360 self._warnings.append(msg)
+361 if slug:
+362 msg = "%s (%s)" % (msg, slug)
+363 if self._debug.should('pid'): 363 ↛ 364line 363 didn't jump to line 364, because the condition on line 363 was never true
+364 msg = "[%d] %s" % (os.getpid(), msg)
+365 sys.stderr.write("Coverage.py warning: %s\n" % msg)
+ +367 if once:
+368 self._no_warn_slugs.append(slug)
+ +370 def get_option(self, option_name):
+371 """Get an option from the configuration.
+ +373 `option_name` is a colon-separated string indicating the section and
+374 option name. For example, the ``branch`` option in the ``[run]``
+375 section of the config file would be indicated with `"run:branch"`.
+ +377 Returns the value of the option. The type depends on the option
+378 selected.
+ +380 As a special case, an `option_name` of ``"paths"`` will return an
+381 OrderedDict with the entire ``[paths]`` section value.
+ +383 .. versionadded:: 4.0
+ +385 """
+386 return self.config.get_option(option_name)
+ +388 def set_option(self, option_name, value):
+389 """Set an option in the configuration.
+ +391 `option_name` is a colon-separated string indicating the section and
+392 option name. For example, the ``branch`` option in the ``[run]``
+393 section of the config file would be indicated with ``"run:branch"``.
+ +395 `value` is the new value for the option. This should be an
+396 appropriate Python value. For example, use True for booleans, not the
+397 string ``"True"``.
+ +399 As an example, calling::
+ +401 cov.set_option("run:branch", True)
+ +403 has the same effect as this configuration file::
+ +405 [run]
+406 branch = True
+ +408 As a special case, an `option_name` of ``"paths"`` will replace the
+409 entire ``[paths]`` section. The value should be an OrderedDict.
+ +411 .. versionadded:: 4.0
+ +413 """
+414 self.config.set_option(option_name, value)
+ +416 def load(self):
+417 """Load previously-collected coverage data from the data file."""
+418 self._init()
+419 if self._collector: 419 ↛ 420line 419 didn't jump to line 420, because the condition on line 419 was never true
+420 self._collector.reset()
+421 should_skip = self.config.parallel and not os.path.exists(self.config.data_file)
+422 if not should_skip:
+423 self._init_data(suffix=None)
+424 self._post_init()
+425 if not should_skip:
+426 self._data.read()
+ +428 def _init_for_start(self):
+429 """Initialization for start()"""
+430 # Construct the collector.
+431 concurrency = self.config.concurrency or ()
+432 if "multiprocessing" in concurrency:
+433 if not patch_multiprocessing:
+434 raise CoverageException( # pragma: only jython
+435 "multiprocessing is not supported on this Python"
+436 )
+437 patch_multiprocessing(rcfile=self.config.config_file)
+ +439 dycon = self.config.dynamic_context
+440 if not dycon or dycon == "none":
+441 context_switchers = []
+442 elif dycon == "test_function": 442 ↛ 445line 442 didn't jump to line 445, because the condition on line 442 was never false
+443 context_switchers = [should_start_context_test_function]
+444 else:
+445 raise CoverageException(
+446 "Don't understand dynamic_context setting: {!r}".format(dycon)
+447 )
+ +449 context_switchers.extend(
+450 plugin.dynamic_context for plugin in self._plugins.context_switchers
+451 )
+ +453 should_start_context = combine_context_switchers(context_switchers)
+ +455 self._collector = Collector(
+456 should_trace=self._should_trace,
+457 check_include=self._check_include_omit_etc,
+458 should_start_context=should_start_context,
+459 file_mapper=self._file_mapper,
+460 timid=self.config.timid,
+461 branch=self.config.branch,
+462 warn=self._warn,
+463 concurrency=concurrency,
+464 )
+ +466 suffix = self._data_suffix_specified
+467 if suffix or self.config.parallel:
+468 if not isinstance(suffix, string_class):
+469 # if data_suffix=True, use .machinename.pid.random
+470 suffix = True
+471 else:
+472 suffix = None
+ +474 self._init_data(suffix)
+ +476 self._collector.use_data(self._data, self.config.context)
+ +478 # Early warning if we aren't going to be able to support plugins.
+479 if self._plugins.file_tracers and not self._collector.supports_plugins:
+480 self._warn(
+481 "Plugin file tracers (%s) aren't supported with %s" % (
+482 ", ".join(
+483 plugin._coverage_plugin_name
+484 for plugin in self._plugins.file_tracers
+485 ),
+486 self._collector.tracer_name(),
+487 )
+488 )
+489 for plugin in self._plugins.file_tracers:
+490 plugin._coverage_enabled = False
+ +492 # Create the file classifying substructure.
+493 self._inorout = InOrOut(
+494 warn=self._warn,
+495 debug=(self._debug if self._debug.should('trace') else None),
+496 )
+497 self._inorout.configure(self.config)
+498 self._inorout.plugins = self._plugins
+499 self._inorout.disp_class = self._collector.file_disposition_class
+ +501 # It's useful to write debug info after initing for start.
+502 self._should_write_debug = True
+ +504 atexit.register(self._atexit)
+ +506 def _init_data(self, suffix):
+507 """Create a data file if we don't have one yet."""
+508 if self._data is None:
+509 # Create the data file. We do this at construction time so that the
+510 # data file will be written into the directory where the process
+511 # started rather than wherever the process eventually chdir'd to.
+512 ensure_dir_for_file(self.config.data_file)
+513 self._data = CoverageData(
+514 basename=self.config.data_file,
+515 suffix=suffix,
+516 warn=self._warn,
+517 debug=self._debug,
+518 no_disk=self._no_disk,
+519 )
+ +521 def start(self):
+522 """Start measuring code coverage.
+ +524 Coverage measurement only occurs in functions called after
+525 :meth:`start` is invoked. Statements in the same scope as
+526 :meth:`start` won't be measured.
+ +528 Once you invoke :meth:`start`, you must also call :meth:`stop`
+529 eventually, or your process might not shut down cleanly.
+ +531 """
+532 self._init()
+533 if not self._inited_for_start:
+534 self._inited_for_start = True
+535 self._init_for_start()
+536 self._post_init()
+ +538 # Issue warnings for possible problems.
+539 self._inorout.warn_conflicting_settings()
+ +541 # See if we think some code that would eventually be measured has
+542 # already been imported.
+543 if self._warn_preimported_source:
+544 self._inorout.warn_already_imported_files()
+ +546 if self._auto_load: 546 ↛ 547line 546 didn't jump to line 547, because the condition on line 546 was never true
+547 self.load()
+ +549 self._collector.start()
+550 self._started = True
+551 self._instances.append(self)
+ +553 def stop(self):
+554 """Stop measuring code coverage."""
+555 if self._instances: 555 ↛ 558line 555 didn't jump to line 558, because the condition on line 555 was never false
+556 if self._instances[-1] is self:
+557 self._instances.pop()
+558 if self._started:
+559 self._collector.stop()
+560 self._started = False
+ +562 def _atexit(self):
+563 """Clean up on process shutdown."""
+564 if self._debug.should("process"): 564 ↛ 565line 564 didn't jump to line 565, because the condition on line 564 was never true
+565 self._debug.write("atexit: pid: {}, instance: {!r}".format(os.getpid(), self))
+566 if self._started:
+567 self.stop()
+568 if self._auto_save: 568 ↛ 569line 568 didn't jump to line 569, because the condition on line 568 was never true
+569 self.save()
+ +571 def erase(self):
+572 """Erase previously collected coverage data.
+ +574 This removes the in-memory data collected in this session as well as
+575 discarding the data file.
+ +577 """
+578 self._init()
+579 self._post_init()
+580 if self._collector:
+581 self._collector.reset()
+582 self._init_data(suffix=None)
+583 self._data.erase(parallel=self.config.parallel)
+584 self._data = None
+585 self._inited_for_start = False
+ +587 def switch_context(self, new_context):
+588 """Switch to a new dynamic context.
+ +590 `new_context` is a string to use as the :ref:`dynamic context
+591 <dynamic_contexts>` label for collected data. If a :ref:`static
+592 context <static_contexts>` is in use, the static and dynamic context
+593 labels will be joined together with a pipe character.
+ +595 Coverage collection must be started already.
+ +597 .. versionadded:: 5.0
+ +599 """
+600 if not self._started: # pragma: part started
+601 raise CoverageException(
+602 "Cannot switch context, coverage is not started"
+603 )
+ +605 if self._collector.should_start_context:
+606 self._warn("Conflicting dynamic contexts", slug="dynamic-conflict", once=True)
+ +608 self._collector.switch_context(new_context)
+ +610 def clear_exclude(self, which='exclude'):
+611 """Clear the exclude list."""
+612 self._init()
+613 setattr(self.config, which + "_list", [])
+614 self._exclude_regex_stale()
+ +616 def exclude(self, regex, which='exclude'):
+617 """Exclude source lines from execution consideration.
+ +619 A number of lists of regular expressions are maintained. Each list
+620 selects lines that are treated differently during reporting.
+ +622 `which` determines which list is modified. The "exclude" list selects
+623 lines that are not considered executable at all. The "partial" list
+624 indicates lines with branches that are not taken.
+ +626 `regex` is a regular expression. The regex is added to the specified
+627 list. If any of the regexes in the list is found in a line, the line
+628 is marked for special treatment during reporting.
+ +630 """
+631 self._init()
+632 excl_list = getattr(self.config, which + "_list")
+633 excl_list.append(regex)
+634 self._exclude_regex_stale()
+ +636 def _exclude_regex_stale(self):
+637 """Drop all the compiled exclusion regexes, a list was modified."""
+638 self._exclude_re.clear()
+ +640 def _exclude_regex(self, which):
+641 """Return a compiled regex for the given exclusion list."""
+642 if which not in self._exclude_re:
+643 excl_list = getattr(self.config, which + "_list")
+644 self._exclude_re[which] = join_regex(excl_list)
+645 return self._exclude_re[which]
+ +647 def get_exclude_list(self, which='exclude'):
+648 """Return a list of excluded regex patterns.
+ +650 `which` indicates which list is desired. See :meth:`exclude` for the
+651 lists that are available, and their meaning.
+ +653 """
+654 self._init()
+655 return getattr(self.config, which + "_list")
+ +657 def save(self):
+658 """Save the collected coverage data to the data file."""
+659 data = self.get_data()
+660 data.write()
+ +662 def combine(self, data_paths=None, strict=False, keep=False):
+663 """Combine together a number of similarly-named coverage data files.
+ +665 All coverage data files whose name starts with `data_file` (from the
+666 coverage() constructor) will be read, and combined together into the
+667 current measurements.
+ +669 `data_paths` is a list of files or directories from which data should
+670 be combined. If no list is passed, then the data files from the
+671 directory indicated by the current data file (probably the current
+672 directory) will be combined.
+ +674 If `strict` is true, then it is an error to attempt to combine when
+675 there are no data files to combine.
+ +677 If `keep` is true, then original input data files won't be deleted.
+ +679 .. versionadded:: 4.0
+680 The `data_paths` parameter.
+ +682 .. versionadded:: 4.3
+683 The `strict` parameter.
+ +685 .. versionadded: 5.5
+686 The `keep` parameter.
+687 """
+688 self._init()
+689 self._init_data(suffix=None)
+690 self._post_init()
+691 self.get_data()
+ +693 aliases = None
+694 if self.config.paths:
+695 aliases = PathAliases()
+696 for paths in self.config.paths.values():
+697 result = paths[0]
+698 for pattern in paths[1:]:
+699 aliases.add(pattern, result)
+ +701 combine_parallel_data(
+702 self._data,
+703 aliases=aliases,
+704 data_paths=data_paths,
+705 strict=strict,
+706 keep=keep,
+707 )
+ +709 def get_data(self):
+710 """Get the collected data.
+ +712 Also warn about various problems collecting data.
+ +714 Returns a :class:`coverage.CoverageData`, the collected coverage data.
+ +716 .. versionadded:: 4.0
+ +718 """
+719 self._init()
+720 self._init_data(suffix=None)
+721 self._post_init()
+ +723 for plugin in self._plugins:
+724 if not plugin._coverage_enabled:
+725 self._collector.plugin_was_disabled(plugin)
+ +727 if self._collector and self._collector.flush_data():
+728 self._post_save_work()
+ +730 return self._data
+ +732 def _post_save_work(self):
+733 """After saving data, look for warnings, post-work, etc.
+ +735 Warn about things that should have happened but didn't.
+736 Look for unexecuted files.
+ +738 """
+739 # If there are still entries in the source_pkgs_unmatched list,
+740 # then we never encountered those packages.
+741 if self._warn_unimported_source: 741 ↛ 745line 741 didn't jump to line 745, because the condition on line 741 was never false
+742 self._inorout.warn_unimported_source()
+ +744 # Find out if we got any data.
+745 if not self._data and self._warn_no_data:
+746 self._warn("No data was collected.", slug="no-data-collected")
+ +748 # Touch all the files that could have executed, so that we can
+749 # mark completely unexecuted files as 0% covered.
+750 if self._data is not None: 750 ↛ 758line 750 didn't jump to line 758, because the condition on line 750 was never false
+751 file_paths = collections.defaultdict(list)
+752 for file_path, plugin_name in self._inorout.find_possibly_unexecuted_files():
+753 file_path = self._file_mapper(file_path)
+754 file_paths[plugin_name].append(file_path)
+755 for plugin_name, paths in file_paths.items():
+756 self._data.touch_files(paths, plugin_name)
+ +758 if self.config.note:
+759 self._warn("The '[run] note' setting is no longer supported.")
+ +761 # Backward compatibility with version 1.
+762 def analysis(self, morf):
+763 """Like `analysis2` but doesn't return excluded line numbers."""
+764 f, s, _, m, mf = self.analysis2(morf)
+765 return f, s, m, mf
+ +767 def analysis2(self, morf):
+768 """Analyze a module.
+ +770 `morf` is a module or a file name. It will be analyzed to determine
+771 its coverage statistics. The return value is a 5-tuple:
+ +773 * The file name for the module.
+774 * A list of line numbers of executable statements.
+775 * A list of line numbers of excluded statements.
+776 * A list of line numbers of statements not run (missing from
+777 execution).
+778 * A readable formatted string of the missing line numbers.
+ +780 The analysis uses the source file itself and the current measured
+781 coverage data.
+ +783 """
+784 analysis = self._analyze(morf)
+785 return (
+786 analysis.filename,
+787 sorted(analysis.statements),
+788 sorted(analysis.excluded),
+789 sorted(analysis.missing),
+790 analysis.missing_formatted(),
+791 )
+ +793 def _analyze(self, it):
+794 """Analyze a single morf or code unit.
+ +796 Returns an `Analysis` object.
+ +798 """
+799 # All reporting comes through here, so do reporting initialization.
+800 self._init()
+801 Numbers.set_precision(self.config.precision)
+802 self._post_init()
+ +804 data = self.get_data()
+805 if not isinstance(it, FileReporter):
+806 it = self._get_file_reporter(it)
+ +808 return Analysis(data, it, self._file_mapper)
+ +810 def _get_file_reporter(self, morf):
+811 """Get a FileReporter for a module or file name."""
+812 plugin = None
+813 file_reporter = "python"
+ +815 if isinstance(morf, string_class):
+816 mapped_morf = self._file_mapper(morf)
+817 plugin_name = self._data.file_tracer(mapped_morf)
+818 if plugin_name:
+819 plugin = self._plugins.get(plugin_name)
+ +821 if plugin: 821 ↛ 830line 821 didn't jump to line 830, because the condition on line 821 was never false
+822 file_reporter = plugin.file_reporter(mapped_morf)
+823 if file_reporter is None: 823 ↛ 824line 823 didn't jump to line 824, because the condition on line 823 was never true
+824 raise CoverageException(
+825 "Plugin %r did not provide a file reporter for %r." % (
+826 plugin._coverage_plugin_name, morf
+827 )
+828 )
+ +830 if file_reporter == "python":
+831 file_reporter = PythonFileReporter(morf, self)
+ +833 return file_reporter
+ +835 def _get_file_reporters(self, morfs=None):
+836 """Get a list of FileReporters for a list of modules or file names.
+ +838 For each module or file name in `morfs`, find a FileReporter. Return
+839 the list of FileReporters.
+ +841 If `morfs` is a single module or file name, this returns a list of one
+842 FileReporter. If `morfs` is empty or None, then the list of all files
+843 measured is used to find the FileReporters.
+ +845 """
+846 if not morfs:
+847 morfs = self._data.measured_files()
+ +849 # Be sure we have a collection.
+850 if not isinstance(morfs, (list, tuple, set)):
+851 morfs = [morfs]
+ +853 file_reporters = [self._get_file_reporter(morf) for morf in morfs]
+854 return file_reporters
+ +856 def report(
+857 self, morfs=None, show_missing=None, ignore_errors=None,
+858 file=None, omit=None, include=None, skip_covered=None,
+859 contexts=None, skip_empty=None, precision=None, sort=None
+860 ):
+861 """Write a textual summary report to `file`.
+ +863 Each module in `morfs` is listed, with counts of statements, executed
+864 statements, missing statements, and a list of lines missed.
+ +866 If `show_missing` is true, then details of which lines or branches are
+867 missing will be included in the report. If `ignore_errors` is true,
+868 then a failure while reporting a single file will not stop the entire
+869 report.
+ +871 `file` is a file-like object, suitable for writing.
+ +873 `include` is a list of file name patterns. Files that match will be
+874 included in the report. Files matching `omit` will not be included in
+875 the report.
+ +877 If `skip_covered` is true, don't report on files with 100% coverage.
+ +879 If `skip_empty` is true, don't report on empty files (those that have
+880 no statements).
+ +882 `contexts` is a list of regular expressions. Only data from
+883 :ref:`dynamic contexts <dynamic_contexts>` that match one of those
+884 expressions (using :func:`re.search <python:re.search>`) will be
+885 included in the report.
+ +887 `precision` is the number of digits to display after the decimal
+888 point for percentages.
+ +890 All of the arguments default to the settings read from the
+891 :ref:`configuration file <config>`.
+ +893 Returns a float, the total percentage covered.
+ +895 .. versionadded:: 4.0
+896 The `skip_covered` parameter.
+ +898 .. versionadded:: 5.0
+899 The `contexts` and `skip_empty` parameters.
+ +901 .. versionadded:: 5.2
+902 The `precision` parameter.
+ +904 """
+905 with override_config(
+906 self,
+907 ignore_errors=ignore_errors, report_omit=omit, report_include=include,
+908 show_missing=show_missing, skip_covered=skip_covered,
+909 report_contexts=contexts, skip_empty=skip_empty, precision=precision,
+910 sort=sort
+911 ):
+912 reporter = SummaryReporter(self)
+913 return reporter.report(morfs, outfile=file)
+ +915 def annotate(
+916 self, morfs=None, directory=None, ignore_errors=None,
+917 omit=None, include=None, contexts=None,
+918 ):
+919 """Annotate a list of modules.
+ +921 Each module in `morfs` is annotated. The source is written to a new
+922 file, named with a ",cover" suffix, with each line prefixed with a
+923 marker to indicate the coverage of the line. Covered lines have ">",
+924 excluded lines have "-", and missing lines have "!".
+ +926 See :meth:`report` for other arguments.
+ +928 """
+929 with override_config(self,
+930 ignore_errors=ignore_errors, report_omit=omit,
+931 report_include=include, report_contexts=contexts,
+932 ):
+933 reporter = AnnotateReporter(self)
+934 reporter.report(morfs, directory=directory)
+ +936 def html_report(
+937 self, morfs=None, directory=None, ignore_errors=None,
+938 omit=None, include=None, extra_css=None, title=None,
+939 skip_covered=None, show_contexts=None, contexts=None,
+940 skip_empty=None, precision=None,
+941 ):
+942 """Generate an HTML report.
+ +944 The HTML is written to `directory`. The file "index.html" is the
+945 overview starting point, with links to more detailed pages for
+946 individual modules.
+ +948 `extra_css` is a path to a file of other CSS to apply on the page.
+949 It will be copied into the HTML directory.
+ +951 `title` is a text string (not HTML) to use as the title of the HTML
+952 report.
+ +954 See :meth:`report` for other arguments.
+ +956 Returns a float, the total percentage covered.
+ +958 .. note::
+959 The HTML report files are generated incrementally based on the
+960 source files and coverage results. If you modify the report files,
+961 the changes will not be considered. You should be careful about
+962 changing the files in the report folder.
+ +964 """
+965 with override_config(self,
+966 ignore_errors=ignore_errors, report_omit=omit, report_include=include,
+967 html_dir=directory, extra_css=extra_css, html_title=title,
+968 html_skip_covered=skip_covered, show_contexts=show_contexts, report_contexts=contexts,
+969 html_skip_empty=skip_empty, precision=precision,
+970 ):
+971 reporter = HtmlReporter(self)
+972 return reporter.report(morfs)
+ +974 def xml_report(
+975 self, morfs=None, outfile=None, ignore_errors=None,
+976 omit=None, include=None, contexts=None, skip_empty=None,
+977 ):
+978 """Generate an XML report of coverage results.
+ +980 The report is compatible with Cobertura reports.
+ +982 Each module in `morfs` is included in the report. `outfile` is the
+983 path to write the file to, "-" will write to stdout.
+ +985 See :meth:`report` for other arguments.
+ +987 Returns a float, the total percentage covered.
+ +989 """
+990 with override_config(self,
+991 ignore_errors=ignore_errors, report_omit=omit, report_include=include,
+992 xml_output=outfile, report_contexts=contexts, skip_empty=skip_empty,
+993 ):
+994 return render_report(self.config.xml_output, XmlReporter(self), morfs)
+ +996 def json_report(
+997 self, morfs=None, outfile=None, ignore_errors=None,
+998 omit=None, include=None, contexts=None, pretty_print=None,
+999 show_contexts=None
+1000 ):
+1001 """Generate a JSON report of coverage results.
+ +1003 Each module in `morfs` is included in the report. `outfile` is the
+1004 path to write the file to, "-" will write to stdout.
+ +1006 See :meth:`report` for other arguments.
+ +1008 Returns a float, the total percentage covered.
+ +1010 .. versionadded:: 5.0
+ +1012 """
+1013 with override_config(self,
+1014 ignore_errors=ignore_errors, report_omit=omit, report_include=include,
+1015 json_output=outfile, report_contexts=contexts, json_pretty_print=pretty_print,
+1016 json_show_contexts=show_contexts
+1017 ):
+1018 return render_report(self.config.json_output, JsonReporter(self), morfs)
+ +1020 def sys_info(self):
+1021 """Return a list of (key, value) pairs showing internal information."""
+ +1023 import coverage as covmod
+ +1025 self._init()
+1026 self._post_init()
+ +1028 def plugin_info(plugins):
+1029 """Make an entry for the sys_info from a list of plug-ins."""
+1030 entries = []
+1031 for plugin in plugins:
+1032 entry = plugin._coverage_plugin_name
+1033 if not plugin._coverage_enabled:
+1034 entry += " (disabled)"
+1035 entries.append(entry)
+1036 return entries
+ +1038 info = [
+1039 ('version', covmod.__version__),
+1040 ('coverage', covmod.__file__),
+1041 ('tracer', self._collector.tracer_name() if self._collector else "-none-"),
+1042 ('CTracer', 'available' if CTracer else "unavailable"),
+1043 ('plugins.file_tracers', plugin_info(self._plugins.file_tracers)),
+1044 ('plugins.configurers', plugin_info(self._plugins.configurers)),
+1045 ('plugins.context_switchers', plugin_info(self._plugins.context_switchers)),
+1046 ('configs_attempted', self.config.attempted_config_files),
+1047 ('configs_read', self.config.config_files_read),
+1048 ('config_file', self.config.config_file),
+1049 ('config_contents',
+1050 repr(self.config._config_contents)
+1051 if self.config._config_contents
+1052 else '-none-'
+1053 ),
+1054 ('data_file', self._data.data_filename() if self._data is not None else "-none-"),
+1055 ('python', sys.version.replace('\n', '')),
+1056 ('platform', platform.platform()),
+1057 ('implementation', platform.python_implementation()),
+1058 ('executable', sys.executable),
+1059 ('def_encoding', sys.getdefaultencoding()),
+1060 ('fs_encoding', sys.getfilesystemencoding()),
+1061 ('pid', os.getpid()),
+1062 ('cwd', os.getcwd()),
+1063 ('path', sys.path),
+1064 ('environment', sorted(
+1065 ("%s = %s" % (k, v))
+1066 for k, v in iitems(os.environ)
+1067 if any(slug in k for slug in ("COV", "PY"))
+1068 )),
+1069 ('command_line', " ".join(getattr(sys, 'argv', ['-none-']))),
+1070 ]
+ +1072 if self._inorout:
+1073 info.extend(self._inorout.sys_info())
+ +1075 info.extend(CoverageData.sys_info())
+ +1077 return info
+ + +1080# Mega debugging...
+1081# $set_env.py: COVERAGE_DEBUG_CALLS - Lots and lots of output about calls to Coverage.
+1082if int(os.environ.get("COVERAGE_DEBUG_CALLS", 0)): # pragma: debugging
+1083 from coverage.debug import decorate_methods, show_calls
+ +1085 Coverage = decorate_methods(show_calls(show_args=True), butnot=['get_data'])(Coverage)
+ + +1088def process_startup():
+1089 """Call this at Python start-up to perhaps measure coverage.
+ +1091 If the environment variable COVERAGE_PROCESS_START is defined, coverage
+1092 measurement is started. The value of the variable is the config file
+1093 to use.
+ +1095 There are two ways to configure your Python installation to invoke this
+1096 function when Python starts:
+ +1098 #. Create or append to sitecustomize.py to add these lines::
+ +1100 import coverage
+1101 coverage.process_startup()
+ +1103 #. Create a .pth file in your Python installation containing::
+ +1105 import coverage; coverage.process_startup()
+ +1107 Returns the :class:`Coverage` instance that was started, or None if it was
+1108 not started by this call.
+ +1110 """
+1111 cps = os.environ.get("COVERAGE_PROCESS_START")
+1112 if not cps: 1112 ↛ 1114line 1112 didn't jump to line 1114, because the condition on line 1112 was never true
+1113 # No request for coverage, nothing to do.
+1114 return None
+ +1116 # This function can be called more than once in a process. This happens
+1117 # because some virtualenv configurations make the same directory visible
+1118 # twice in sys.path. This means that the .pth file will be found twice,
+1119 # and executed twice, executing this function twice. We set a global
+1120 # flag (an attribute on this function) to indicate that coverage.py has
+1121 # already been started, so we can avoid doing it twice.
+1122 #
+1123 # https://github.com/nedbat/coveragepy/issues/340 has more details.
+ +1125 if hasattr(process_startup, "coverage"): 1125 ↛ 1130line 1125 didn't jump to line 1130, because the condition on line 1125 was never false
+1126 # We've annotated this function before, so we must have already
+1127 # started coverage.py in this process. Nothing to do.
+1128 return None
+ +1130 cov = Coverage(config_file=cps)
+1131 process_startup.coverage = cov
+1132 cov._warn_no_data = False
+1133 cov._warn_unimported_source = False
+1134 cov._warn_preimported_source = False
+1135 cov._auto_save = True
+1136 cov.start()
+ +1138 return cov
+ + +1141def _prevent_sub_process_measurement():
+1142 """Stop any subprocess auto-measurement from writing data."""
+1143 auto_created_coverage = getattr(process_startup, "coverage", None)
+1144 if auto_created_coverage is not None:
+1145 auto_created_coverage._auto_save = False
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Coverage data for coverage.py.
+ +6This file had the 4.x JSON data support, which is now gone. This file still
+7has storage-agnostic helpers, and is kept to avoid changing too many imports.
+8CoverageData is now defined in sqldata.py, and imported here to keep the
+9imports working.
+ +11"""
+ +13import glob
+14import os.path
+ +16from coverage.misc import CoverageException, file_be_gone
+17from coverage.sqldata import CoverageData
+ + +20def line_counts(data, fullpath=False):
+21 """Return a dict summarizing the line coverage data.
+ +23 Keys are based on the file names, and values are the number of executed
+24 lines. If `fullpath` is true, then the keys are the full pathnames of
+25 the files, otherwise they are the basenames of the files.
+ +27 Returns a dict mapping file names to counts of lines.
+ +29 """
+30 summ = {}
+31 if fullpath:
+32 filename_fn = lambda f: f
+33 else:
+34 filename_fn = os.path.basename
+35 for filename in data.measured_files():
+36 summ[filename_fn(filename)] = len(data.lines(filename))
+37 return summ
+ + +40def add_data_to_hash(data, filename, hasher):
+41 """Contribute `filename`'s data to the `hasher`.
+ +43 `hasher` is a `coverage.misc.Hasher` instance to be updated with
+44 the file's data. It should only get the results data, not the run
+45 data.
+ +47 """
+48 if data.has_arcs():
+49 hasher.update(sorted(data.arcs(filename) or []))
+50 else:
+51 hasher.update(sorted(data.lines(filename) or []))
+52 hasher.update(data.file_tracer(filename))
+ + +55def combine_parallel_data(data, aliases=None, data_paths=None, strict=False, keep=False):
+56 """Combine a number of data files together.
+ +58 Treat `data.filename` as a file prefix, and combine the data from all
+59 of the data files starting with that prefix plus a dot.
+ +61 If `aliases` is provided, it's a `PathAliases` object that is used to
+62 re-map paths to match the local machine's.
+ +64 If `data_paths` is provided, it is a list of directories or files to
+65 combine. Directories are searched for files that start with
+66 `data.filename` plus dot as a prefix, and those files are combined.
+ +68 If `data_paths` is not provided, then the directory portion of
+69 `data.filename` is used as the directory to search for data files.
+ +71 Unless `keep` is True every data file found and combined is then deleted from disk. If a file
+72 cannot be read, a warning will be issued, and the file will not be
+73 deleted.
+ +75 If `strict` is true, and no files are found to combine, an error is
+76 raised.
+ +78 """
+79 # Because of the os.path.abspath in the constructor, data_dir will
+80 # never be an empty string.
+81 data_dir, local = os.path.split(data.base_filename())
+82 localdot = local + '.*'
+ +84 data_paths = data_paths or [data_dir]
+85 files_to_combine = []
+86 for p in data_paths:
+87 if os.path.isfile(p):
+88 files_to_combine.append(os.path.abspath(p))
+89 elif os.path.isdir(p):
+90 pattern = os.path.join(os.path.abspath(p), localdot)
+91 files_to_combine.extend(glob.glob(pattern))
+92 else:
+93 raise CoverageException("Couldn't combine from non-existent path '%s'" % (p,))
+ +95 if strict and not files_to_combine:
+96 raise CoverageException("No data to combine")
+ +98 files_combined = 0
+99 for f in files_to_combine:
+100 if f == data.data_filename():
+101 # Sometimes we are combining into a file which is one of the
+102 # parallel files. Skip that file.
+103 if data._debug.should('dataio'): 103 ↛ 104line 103 didn't jump to line 104, because the condition on line 103 was never true
+104 data._debug.write("Skipping combining ourself: %r" % (f,))
+105 continue
+106 if data._debug.should('dataio'): 106 ↛ 107line 106 didn't jump to line 107, because the condition on line 106 was never true
+107 data._debug.write("Combining data file %r" % (f,))
+108 try:
+109 new_data = CoverageData(f, debug=data._debug)
+110 new_data.read()
+111 except CoverageException as exc:
+112 if data._warn: 112 ↛ 99line 112 didn't jump to line 99, because the condition on line 112 was never false
+113 # The CoverageException has the file name in it, so just
+114 # use the message as the warning.
+115 data._warn(str(exc))
+116 else:
+117 data.update(new_data, aliases=aliases)
+118 files_combined += 1
+119 if not keep:
+120 if data._debug.should('dataio'): 120 ↛ 121line 120 didn't jump to line 121, because the condition on line 120 was never true
+121 data._debug.write("Deleting combined data file %r" % (f,))
+122 file_be_gone(f)
+ +124 if strict and not files_combined:
+125 raise CoverageException("No usable data files")
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Control of and utilities for debugging."""
+ +6import contextlib
+7import functools
+8import inspect
+9import itertools
+10import os
+11import pprint
+12import sys
+13try:
+14 import _thread
+15except ImportError:
+16 import thread as _thread
+ +18from coverage.backward import reprlib, StringIO
+19from coverage.misc import isolate_module
+ +21os = isolate_module(os)
+ + +24# When debugging, it can be helpful to force some options, especially when
+25# debugging the configuration mechanisms you usually use to control debugging!
+26# This is a list of forced debugging options.
+27FORCED_DEBUG = []
+28FORCED_DEBUG_FILE = None
+ + +31class DebugControl(object):
+32 """Control and output for debugging."""
+ +34 show_repr_attr = False # For SimpleReprMixin
+ +36 def __init__(self, options, output):
+37 """Configure the options and output file for debugging."""
+38 self.options = list(options) + FORCED_DEBUG
+39 self.suppress_callers = False
+ +41 filters = []
+42 if self.should('pid'):
+43 filters.append(add_pid_and_tid)
+44 self.output = DebugOutputFile.get_one(
+45 output,
+46 show_process=self.should('process'),
+47 filters=filters,
+48 )
+49 self.raw_output = self.output.outfile
+ +51 def __repr__(self):
+52 return "<DebugControl options=%r raw_output=%r>" % (self.options, self.raw_output)
+ +54 def should(self, option):
+55 """Decide whether to output debug information in category `option`."""
+56 if option == "callers" and self.suppress_callers:
+57 return False
+58 return (option in self.options)
+ +60 @contextlib.contextmanager
+61 def without_callers(self):
+62 """A context manager to prevent call stacks from being logged."""
+63 old = self.suppress_callers
+64 self.suppress_callers = True
+65 try:
+66 yield
+67 finally:
+68 self.suppress_callers = old
+ +70 def write(self, msg):
+71 """Write a line of debug output.
+ +73 `msg` is the line to write. A newline will be appended.
+ +75 """
+76 self.output.write(msg+"\n")
+77 if self.should('self'): 77 ↛ 78line 77 didn't jump to line 78, because the condition on line 77 was never true
+78 caller_self = inspect.stack()[1][0].f_locals.get('self')
+79 if caller_self is not None:
+80 self.output.write("self: {!r}\n".format(caller_self))
+81 if self.should('callers'):
+82 dump_stack_frames(out=self.output, skip=1)
+83 self.output.flush()
+ + +86class DebugControlString(DebugControl):
+87 """A `DebugControl` that writes to a StringIO, for testing."""
+88 def __init__(self, options):
+89 super(DebugControlString, self).__init__(options, StringIO())
+ +91 def get_output(self):
+92 """Get the output text from the `DebugControl`."""
+93 return self.raw_output.getvalue()
+ + +96class NoDebugging(object):
+97 """A replacement for DebugControl that will never try to do anything."""
+98 def should(self, option): # pylint: disable=unused-argument
+99 """Should we write debug messages? Never."""
+100 return False
+ + +103def info_header(label):
+104 """Make a nice header string."""
+105 return "--{:-<60s}".format(" "+label+" ")
+ + +108def info_formatter(info):
+109 """Produce a sequence of formatted lines from info.
+ +111 `info` is a sequence of pairs (label, data). The produced lines are
+112 nicely formatted, ready to print.
+ +114 """
+115 info = list(info)
+116 if not info:
+117 return
+118 label_len = 30
+119 assert all(len(l) < label_len for l, _ in info)
+120 for label, data in info:
+121 if data == []:
+122 data = "-none-"
+123 if isinstance(data, (list, set, tuple)):
+124 prefix = "%*s:" % (label_len, label)
+125 for e in data:
+126 yield "%*s %s" % (label_len+1, prefix, e)
+127 prefix = ""
+128 else:
+129 yield "%*s: %s" % (label_len, label, data)
+ + +132def write_formatted_info(writer, header, info):
+133 """Write a sequence of (label,data) pairs nicely."""
+134 writer.write(info_header(header))
+135 for line in info_formatter(info):
+136 writer.write(" %s" % line)
+ + +139def short_stack(limit=None, skip=0):
+140 """Return a string summarizing the call stack.
+ +142 The string is multi-line, with one line per stack frame. Each line shows
+143 the function name, the file name, and the line number:
+ +145 ...
+146 start_import_stop : /Users/ned/coverage/trunk/tests/coveragetest.py @95
+147 import_local_file : /Users/ned/coverage/trunk/tests/coveragetest.py @81
+148 import_local_file : /Users/ned/coverage/trunk/coverage/backward.py @159
+149 ...
+ +151 `limit` is the number of frames to include, defaulting to all of them.
+ +153 `skip` is the number of frames to skip, so that debugging functions can
+154 call this and not be included in the result.
+ +156 """
+157 stack = inspect.stack()[limit:skip:-1]
+158 return "\n".join("%30s : %s:%d" % (t[3], t[1], t[2]) for t in stack)
+ + +161def dump_stack_frames(limit=None, out=None, skip=0):
+162 """Print a summary of the stack to stdout, or someplace else."""
+163 out = out or sys.stdout
+164 out.write(short_stack(limit=limit, skip=skip+1))
+165 out.write("\n")
+ + +168def clipped_repr(text, numchars=50):
+169 """`repr(text)`, but limited to `numchars`."""
+170 r = reprlib.Repr()
+171 r.maxstring = numchars
+172 return r.repr(text)
+ + +175def short_id(id64):
+176 """Given a 64-bit id, make a shorter 16-bit one."""
+177 id16 = 0
+178 for offset in range(0, 64, 16):
+179 id16 ^= id64 >> offset
+180 return id16 & 0xFFFF
+ + +183def add_pid_and_tid(text):
+184 """A filter to add pid and tid to debug messages."""
+185 # Thread ids are useful, but too long. Make a shorter one.
+186 tid = "{:04x}".format(short_id(_thread.get_ident()))
+187 text = "{:5d}.{}: {}".format(os.getpid(), tid, text)
+188 return text
+ + +191class SimpleReprMixin(object):
+192 """A mixin implementing a simple __repr__."""
+193 simple_repr_ignore = ['simple_repr_ignore', '$coverage.object_id']
+ +195 def __repr__(self):
+196 show_attrs = (
+197 (k, v) for k, v in self.__dict__.items()
+198 if getattr(v, "show_repr_attr", True)
+199 and not callable(v)
+200 and k not in self.simple_repr_ignore
+201 )
+202 return "<{klass} @0x{id:x} {attrs}>".format(
+203 klass=self.__class__.__name__,
+204 id=id(self),
+205 attrs=" ".join("{}={!r}".format(k, v) for k, v in show_attrs),
+206 )
+ + +209def simplify(v): # pragma: debugging
+210 """Turn things which are nearly dict/list/etc into dict/list/etc."""
+211 if isinstance(v, dict):
+212 return {k:simplify(vv) for k, vv in v.items()}
+213 elif isinstance(v, (list, tuple)):
+214 return type(v)(simplify(vv) for vv in v)
+215 elif hasattr(v, "__dict__"):
+216 return simplify({'.'+k: v for k, v in v.__dict__.items()})
+217 else:
+218 return v
+ + +221def pp(v): # pragma: debugging
+222 """Debug helper to pretty-print data, including SimpleNamespace objects."""
+223 # Might not be needed in 3.9+
+224 pprint.pprint(simplify(v))
+ + +227def filter_text(text, filters):
+228 """Run `text` through a series of filters.
+ +230 `filters` is a list of functions. Each takes a string and returns a
+231 string. Each is run in turn.
+ +233 Returns: the final string that results after all of the filters have
+234 run.
+ +236 """
+237 clean_text = text.rstrip()
+238 ending = text[len(clean_text):]
+239 text = clean_text
+240 for fn in filters:
+241 lines = []
+242 for line in text.splitlines():
+243 lines.extend(fn(line).splitlines())
+244 text = "\n".join(lines)
+245 return text + ending
+ + +248class CwdTracker(object): # pragma: debugging
+249 """A class to add cwd info to debug messages."""
+250 def __init__(self):
+251 self.cwd = None
+ +253 def filter(self, text):
+254 """Add a cwd message for each new cwd."""
+255 cwd = os.getcwd()
+256 if cwd != self.cwd:
+257 text = "cwd is now {!r}\n".format(cwd) + text
+258 self.cwd = cwd
+259 return text
+ + +262class DebugOutputFile(object): # pragma: debugging
+263 """A file-like object that includes pid and cwd information."""
+264 def __init__(self, outfile, show_process, filters):
+265 self.outfile = outfile
+266 self.show_process = show_process
+267 self.filters = list(filters)
+ +269 if self.show_process:
+270 self.filters.insert(0, CwdTracker().filter)
+271 self.write("New process: executable: %r\n" % (sys.executable,))
+272 self.write("New process: cmd: %r\n" % (getattr(sys, 'argv', None),))
+273 if hasattr(os, 'getppid'):
+274 self.write("New process: pid: %r, parent pid: %r\n" % (os.getpid(), os.getppid()))
+ +276 SYS_MOD_NAME = '$coverage.debug.DebugOutputFile.the_one'
+ +278 @classmethod
+279 def get_one(cls, fileobj=None, show_process=True, filters=(), interim=False):
+280 """Get a DebugOutputFile.
+ +282 If `fileobj` is provided, then a new DebugOutputFile is made with it.
+ +284 If `fileobj` isn't provided, then a file is chosen
+285 (COVERAGE_DEBUG_FILE, or stderr), and a process-wide singleton
+286 DebugOutputFile is made.
+ +288 `show_process` controls whether the debug file adds process-level
+289 information, and filters is a list of other message filters to apply.
+ +291 `filters` are the text filters to apply to the stream to annotate with
+292 pids, etc.
+ +294 If `interim` is true, then a future `get_one` can replace this one.
+ +296 """
+297 if fileobj is not None:
+298 # Make DebugOutputFile around the fileobj passed.
+299 return cls(fileobj, show_process, filters)
+ +301 # Because of the way igor.py deletes and re-imports modules,
+302 # this class can be defined more than once. But we really want
+303 # a process-wide singleton. So stash it in sys.modules instead of
+304 # on a class attribute. Yes, this is aggressively gross.
+305 the_one, is_interim = sys.modules.get(cls.SYS_MOD_NAME, (None, True))
+306 if the_one is None or is_interim:
+307 if fileobj is None:
+308 debug_file_name = os.environ.get("COVERAGE_DEBUG_FILE", FORCED_DEBUG_FILE)
+309 if debug_file_name:
+310 fileobj = open(debug_file_name, "a")
+311 else:
+312 fileobj = sys.stderr
+313 the_one = cls(fileobj, show_process, filters)
+314 sys.modules[cls.SYS_MOD_NAME] = (the_one, interim)
+315 return the_one
+ +317 def write(self, text):
+318 """Just like file.write, but filter through all our filters."""
+319 self.outfile.write(filter_text(text, self.filters))
+320 self.outfile.flush()
+ +322 def flush(self):
+323 """Flush our file."""
+324 self.outfile.flush()
+ + +327def log(msg, stack=False): # pragma: debugging
+328 """Write a log message as forcefully as possible."""
+329 out = DebugOutputFile.get_one(interim=True)
+330 out.write(msg+"\n")
+331 if stack:
+332 dump_stack_frames(out=out, skip=1)
+ + +335def decorate_methods(decorator, butnot=(), private=False): # pragma: debugging
+336 """A class decorator to apply a decorator to methods."""
+337 def _decorator(cls):
+338 for name, meth in inspect.getmembers(cls, inspect.isroutine):
+339 if name not in cls.__dict__:
+340 continue
+341 if name != "__init__":
+342 if not private and name.startswith("_"):
+343 continue
+344 if name in butnot:
+345 continue
+346 setattr(cls, name, decorator(meth))
+347 return cls
+348 return _decorator
+ + +351def break_in_pudb(func): # pragma: debugging
+352 """A function decorator to stop in the debugger for each call."""
+353 @functools.wraps(func)
+354 def _wrapper(*args, **kwargs):
+355 import pudb
+356 sys.stdout = sys.__stdout__
+357 pudb.set_trace()
+358 return func(*args, **kwargs)
+359 return _wrapper
+ + +362OBJ_IDS = itertools.count()
+363CALLS = itertools.count()
+364OBJ_ID_ATTR = "$coverage.object_id"
+ +366def show_calls(show_args=True, show_stack=False, show_return=False): # pragma: debugging
+367 """A method decorator to debug-log each call to the function."""
+368 def _decorator(func):
+369 @functools.wraps(func)
+370 def _wrapper(self, *args, **kwargs):
+371 oid = getattr(self, OBJ_ID_ATTR, None)
+372 if oid is None:
+373 oid = "{:08d} {:04d}".format(os.getpid(), next(OBJ_IDS))
+374 setattr(self, OBJ_ID_ATTR, oid)
+375 extra = ""
+376 if show_args:
+377 eargs = ", ".join(map(repr, args))
+378 ekwargs = ", ".join("{}={!r}".format(*item) for item in kwargs.items())
+379 extra += "("
+380 extra += eargs
+381 if eargs and ekwargs:
+382 extra += ", "
+383 extra += ekwargs
+384 extra += ")"
+385 if show_stack:
+386 extra += " @ "
+387 extra += "; ".join(_clean_stack_line(l) for l in short_stack().splitlines())
+388 callid = next(CALLS)
+389 msg = "{} {:04d} {}{}\n".format(oid, callid, func.__name__, extra)
+390 DebugOutputFile.get_one(interim=True).write(msg)
+391 ret = func(self, *args, **kwargs)
+392 if show_return:
+393 msg = "{} {:04d} {} return {!r}\n".format(oid, callid, func.__name__, ret)
+394 DebugOutputFile.get_one(interim=True).write(msg)
+395 return ret
+396 return _wrapper
+397 return _decorator
+ + +400def _clean_stack_line(s): # pragma: debugging
+401 """Simplify some paths in a stack trace, for compactness."""
+402 s = s.strip()
+403 s = s.replace(os.path.dirname(__file__) + '/', '')
+404 s = s.replace(os.path.dirname(os.__file__) + '/', '')
+405 s = s.replace(sys.prefix + '/', '')
+406 return s
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Simple value objects for tracking what to do with files."""
+ + +7class FileDisposition(object):
+8 """A simple value type for recording what to do with a file."""
+9 pass
+ + +12# FileDisposition "methods": FileDisposition is a pure value object, so it can
+13# be implemented in either C or Python. Acting on them is done with these
+14# functions.
+ +16def disposition_init(cls, original_filename):
+17 """Construct and initialize a new FileDisposition object."""
+18 disp = cls()
+19 disp.original_filename = original_filename
+20 disp.canonical_filename = original_filename
+21 disp.source_filename = None
+22 disp.trace = False
+23 disp.reason = ""
+24 disp.file_tracer = None
+25 disp.has_dynamic_filename = False
+26 return disp
+ + +29def disposition_debug_msg(disp):
+30 """Make a nice debug message of what the FileDisposition is doing."""
+31 if disp.trace:
+32 msg = "Tracing %r" % (disp.original_filename,)
+33 if disp.file_tracer:
+34 msg += ": will be traced by %r" % disp.file_tracer
+35 else:
+36 msg = "Not tracing %r: %s" % (disp.original_filename, disp.reason)
+37 return msg
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Determine facts about the environment."""
+ +6import os
+7import platform
+8import sys
+ +10# Operating systems.
+11WINDOWS = sys.platform == "win32"
+12LINUX = sys.platform.startswith("linux")
+ +14# Python implementations.
+15CPYTHON = (platform.python_implementation() == "CPython")
+16PYPY = (platform.python_implementation() == "PyPy")
+17JYTHON = (platform.python_implementation() == "Jython")
+18IRONPYTHON = (platform.python_implementation() == "IronPython")
+ +20# Python versions. We amend version_info with one more value, a zero if an
+21# official version, or 1 if built from source beyond an official version.
+22PYVERSION = sys.version_info + (int(platform.python_version()[-1] == "+"),)
+23PY2 = PYVERSION < (3, 0)
+24PY3 = PYVERSION >= (3, 0)
+ +26if PYPY:
+27 PYPYVERSION = sys.pypy_version_info
+ +29PYPY2 = PYPY and PY2
+30PYPY3 = PYPY and PY3
+ +32# Python behavior.
+33class PYBEHAVIOR(object):
+34 """Flags indicating this Python's behavior."""
+ +36 # Does Python conform to PEP626, Precise line numbers for debugging and other tools.
+37 # https://www.python.org/dev/peps/pep-0626
+38 pep626 = CPYTHON and (PYVERSION > (3, 10, 0, 'alpha', 4))
+ +40 # Is "if __debug__" optimized away?
+41 if PYPY3:
+42 optimize_if_debug = True
+43 elif PYPY2: 43 ↛ 44line 43 didn't jump to line 44, because the condition on line 43 was never true
+44 optimize_if_debug = False
+45 else:
+46 optimize_if_debug = not pep626
+ +48 # Is "if not __debug__" optimized away?
+49 optimize_if_not_debug = (not PYPY) and (PYVERSION >= (3, 7, 0, 'alpha', 4))
+50 if pep626:
+51 optimize_if_not_debug = False
+52 if PYPY3:
+53 optimize_if_not_debug = True
+ +55 # Is "if not __debug__" optimized away even better?
+56 optimize_if_not_debug2 = (not PYPY) and (PYVERSION >= (3, 8, 0, 'beta', 1))
+57 if pep626:
+58 optimize_if_not_debug2 = False
+ +60 # Do we have yield-from?
+61 yield_from = (PYVERSION >= (3, 3))
+ +63 # Do we have PEP 420 namespace packages?
+64 namespaces_pep420 = (PYVERSION >= (3, 3))
+ +66 # Do .pyc files have the source file size recorded in them?
+67 size_in_pyc = (PYVERSION >= (3, 3))
+ +69 # Do we have async and await syntax?
+70 async_syntax = (PYVERSION >= (3, 5))
+ +72 # PEP 448 defined additional unpacking generalizations
+73 unpackings_pep448 = (PYVERSION >= (3, 5))
+ +75 # Can co_lnotab have negative deltas?
+76 negative_lnotab = (PYVERSION >= (3, 6)) and not (PYPY and PYPYVERSION < (7, 2))
+ +78 # Do .pyc files conform to PEP 552? Hash-based pyc's.
+79 hashed_pyc_pep552 = (PYVERSION >= (3, 7, 0, 'alpha', 4))
+ +81 # Python 3.7.0b3 changed the behavior of the sys.path[0] entry for -m. It
+82 # used to be an empty string (meaning the current directory). It changed
+83 # to be the actual path to the current directory, so that os.chdir wouldn't
+84 # affect the outcome.
+85 actual_syspath0_dash_m = CPYTHON and (PYVERSION >= (3, 7, 0, 'beta', 3))
+ +87 # 3.7 changed how functions with only docstrings are numbered.
+88 docstring_only_function = (not PYPY) and ((3, 7, 0, 'beta', 5) <= PYVERSION <= (3, 10))
+ +90 # When a break/continue/return statement in a try block jumps to a finally
+91 # block, does the finally block do the break/continue/return (pre-3.8), or
+92 # does the finally jump back to the break/continue/return (3.8) to do the
+93 # work?
+94 finally_jumps_back = ((3, 8) <= PYVERSION < (3, 10))
+ +96 # When a function is decorated, does the trace function get called for the
+97 # @-line and also the def-line (new behavior in 3.8)? Or just the @-line
+98 # (old behavior)?
+99 trace_decorated_def = (PYVERSION >= (3, 8))
+ +101 # Are while-true loops optimized into absolute jumps with no loop setup?
+102 nix_while_true = (PYVERSION >= (3, 8))
+ +104 # Python 3.9a1 made sys.argv[0] and other reported files absolute paths.
+105 report_absolute_files = (PYVERSION >= (3, 9))
+ +107 # Lines after break/continue/return/raise are no longer compiled into the
+108 # bytecode. They used to be marked as missing, now they aren't executable.
+109 omit_after_jump = pep626
+ +111 # PyPy has always omitted statements after return.
+112 omit_after_return = omit_after_jump or PYPY
+ +114 # Modules used to have firstlineno equal to the line number of the first
+115 # real line of code. Now they always start at 1.
+116 module_firstline_1 = pep626
+ +118 # Are "if 0:" lines (and similar) kept in the compiled code?
+119 keep_constant_test = pep626
+ +121# Coverage.py specifics.
+ +123# Are we using the C-implemented trace function?
+124C_TRACER = os.getenv('COVERAGE_TEST_TRACER', 'c') == 'c'
+ +126# Are we coverage-measuring ourselves?
+127METACOV = os.getenv('COVERAGE_COVERAGE', '') != ''
+ +129# Are we running our test suite?
+130# Even when running tests, you can use COVERAGE_TESTING=0 to disable the
+131# test-specific behavior like contracts.
+132TESTING = os.getenv('COVERAGE_TESTING', '') == 'True'
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Execute files of Python code."""
+ +6import inspect
+7import marshal
+8import os
+9import struct
+10import sys
+11import types
+ +13from coverage import env
+14from coverage.backward import BUILTINS
+15from coverage.backward import PYC_MAGIC_NUMBER, imp, importlib_util_find_spec
+16from coverage.files import canonical_filename, python_reported_file
+17from coverage.misc import CoverageException, ExceptionDuringRun, NoCode, NoSource, isolate_module
+18from coverage.phystokens import compile_unicode
+19from coverage.python import get_python_source
+ +21os = isolate_module(os)
+ + +24class DummyLoader(object):
+25 """A shim for the pep302 __loader__, emulating pkgutil.ImpLoader.
+ +27 Currently only implements the .fullname attribute
+28 """
+29 def __init__(self, fullname, *_args):
+30 self.fullname = fullname
+ + +33if importlib_util_find_spec:
+34 def find_module(modulename):
+35 """Find the module named `modulename`.
+ +37 Returns the file path of the module, the name of the enclosing
+38 package, and the spec.
+39 """
+40 try:
+41 spec = importlib_util_find_spec(modulename)
+42 except ImportError as err:
+43 raise NoSource(str(err))
+44 if not spec:
+45 raise NoSource("No module named %r" % (modulename,))
+46 pathname = spec.origin
+47 packagename = spec.name
+48 if spec.submodule_search_locations:
+49 mod_main = modulename + ".__main__"
+50 spec = importlib_util_find_spec(mod_main)
+51 if not spec:
+52 raise NoSource(
+53 "No module named %s; "
+54 "%r is a package and cannot be directly executed"
+55 % (mod_main, modulename)
+56 )
+57 pathname = spec.origin
+58 packagename = spec.name
+59 packagename = packagename.rpartition(".")[0]
+60 return pathname, packagename, spec
+61else:
+62 def find_module(modulename):
+63 """Find the module named `modulename`.
+ +65 Returns the file path of the module, the name of the enclosing
+66 package, and None (where a spec would have been).
+67 """
+68 openfile = None
+69 glo, loc = globals(), locals()
+70 try:
+71 # Search for the module - inside its parent package, if any - using
+72 # standard import mechanics.
+73 if '.' in modulename:
+74 packagename, name = modulename.rsplit('.', 1)
+75 package = __import__(packagename, glo, loc, ['__path__'])
+76 searchpath = package.__path__
+77 else:
+78 packagename, name = None, modulename
+79 searchpath = None # "top-level search" in imp.find_module()
+80 openfile, pathname, _ = imp.find_module(name, searchpath)
+ +82 # Complain if this is a magic non-file module.
+83 if openfile is None and pathname is None: 83 ↛ 84line 83 didn't jump to line 84, because the condition on line 83 was never true
+84 raise NoSource(
+85 "module does not live in a file: %r" % modulename
+86 )
+ +88 # If `modulename` is actually a package, not a mere module, then we
+89 # pretend to be Python 2.7 and try running its __main__.py script.
+90 if openfile is None:
+91 packagename = modulename
+92 name = '__main__'
+93 package = __import__(packagename, glo, loc, ['__path__'])
+94 searchpath = package.__path__
+95 openfile, pathname, _ = imp.find_module(name, searchpath)
+96 except ImportError as err:
+97 raise NoSource(str(err))
+98 finally:
+99 if openfile: 99 ↛ 102line 99 didn't jump to line 102, because the condition on line 99 was never false
+100 openfile.close() 100 ↛ exitline 100 didn't except from function 'find_module', because the raise on line 97 wasn't executed
+ +102 return pathname, packagename, None
+ + +105class PyRunner(object):
+106 """Multi-stage execution of Python code.
+ +108 This is meant to emulate real Python execution as closely as possible.
+ +110 """
+111 def __init__(self, args, as_module=False):
+112 self.args = args
+113 self.as_module = as_module
+ +115 self.arg0 = args[0]
+116 self.package = self.modulename = self.pathname = self.loader = self.spec = None
+ +118 def prepare(self):
+119 """Set sys.path properly.
+ +121 This needs to happen before any importing, and without importing anything.
+122 """
+123 if self.as_module:
+124 if env.PYBEHAVIOR.actual_syspath0_dash_m:
+125 path0 = os.getcwd()
+126 else:
+127 path0 = ""
+128 elif os.path.isdir(self.arg0):
+129 # Running a directory means running the __main__.py file in that
+130 # directory.
+131 path0 = self.arg0
+132 else:
+133 path0 = os.path.abspath(os.path.dirname(self.arg0))
+ +135 if os.path.isdir(sys.path[0]):
+136 # sys.path fakery. If we are being run as a command, then sys.path[0]
+137 # is the directory of the "coverage" script. If this is so, replace
+138 # sys.path[0] with the directory of the file we're running, or the
+139 # current directory when running modules. If it isn't so, then we
+140 # don't know what's going on, and just leave it alone.
+141 top_file = inspect.stack()[-1][0].f_code.co_filename
+142 sys_path_0_abs = os.path.abspath(sys.path[0])
+143 top_file_dir_abs = os.path.abspath(os.path.dirname(top_file))
+144 sys_path_0_abs = canonical_filename(sys_path_0_abs)
+145 top_file_dir_abs = canonical_filename(top_file_dir_abs)
+146 if sys_path_0_abs != top_file_dir_abs:
+147 path0 = None
+ +149 else:
+150 # sys.path[0] is a file. Is the next entry the directory containing
+151 # that file?
+152 if sys.path[1] == os.path.dirname(sys.path[0]):
+153 # Can it be right to always remove that?
+154 del sys.path[1]
+ +156 if path0 is not None:
+157 sys.path[0] = python_reported_file(path0)
+ +159 def _prepare2(self):
+160 """Do more preparation to run Python code.
+ +162 Includes finding the module to run and adjusting sys.argv[0].
+163 This method is allowed to import code.
+ +165 """
+166 if self.as_module:
+167 self.modulename = self.arg0
+168 pathname, self.package, self.spec = find_module(self.modulename)
+169 if self.spec is not None:
+170 self.modulename = self.spec.name
+171 self.loader = DummyLoader(self.modulename)
+172 self.pathname = os.path.abspath(pathname)
+173 self.args[0] = self.arg0 = self.pathname
+174 elif os.path.isdir(self.arg0):
+175 # Running a directory means running the __main__.py file in that
+176 # directory.
+177 for ext in [".py", ".pyc", ".pyo"]:
+178 try_filename = os.path.join(self.arg0, "__main__" + ext)
+179 if os.path.exists(try_filename):
+180 self.arg0 = try_filename
+181 break
+182 else:
+183 raise NoSource("Can't find '__main__' module in '%s'" % self.arg0)
+ +185 if env.PY2:
+186 self.arg0 = os.path.abspath(self.arg0)
+ +188 # Make a spec. I don't know if this is the right way to do it.
+189 try:
+190 import importlib.machinery
+191 except ImportError:
+192 pass
+193 else:
+194 try_filename = python_reported_file(try_filename)
+195 self.spec = importlib.machinery.ModuleSpec("__main__", None, origin=try_filename)
+196 self.spec.has_location = True
+197 self.package = ""
+198 self.loader = DummyLoader("__main__")
+199 else:
+200 if env.PY3:
+201 self.loader = DummyLoader("__main__")
+ +203 self.arg0 = python_reported_file(self.arg0)
+ +205 def run(self):
+206 """Run the Python code!"""
+ +208 self._prepare2()
+ +210 # Create a module to serve as __main__
+211 main_mod = types.ModuleType('__main__')
+ +213 from_pyc = self.arg0.endswith((".pyc", ".pyo"))
+214 main_mod.__file__ = self.arg0
+215 if from_pyc:
+216 main_mod.__file__ = main_mod.__file__[:-1]
+217 if self.package is not None:
+218 main_mod.__package__ = self.package
+219 main_mod.__loader__ = self.loader
+220 if self.spec is not None:
+221 main_mod.__spec__ = self.spec
+ +223 main_mod.__builtins__ = BUILTINS
+ +225 sys.modules['__main__'] = main_mod
+ +227 # Set sys.argv properly.
+228 sys.argv = self.args
+ +230 try:
+231 # Make a code object somehow.
+232 if from_pyc:
+233 code = make_code_from_pyc(self.arg0)
+234 else:
+235 code = make_code_from_py(self.arg0)
+236 except CoverageException:
+237 raise
+238 except Exception as exc:
+239 msg = "Couldn't run '{filename}' as Python code: {exc.__class__.__name__}: {exc}"
+240 raise CoverageException(msg.format(filename=self.arg0, exc=exc))
+ +242 # Execute the code object.
+243 # Return to the original directory in case the test code exits in
+244 # a non-existent directory.
+245 cwd = os.getcwd()
+246 try:
+247 exec(code, main_mod.__dict__)
+248 except SystemExit: # pylint: disable=try-except-raise
+249 # The user called sys.exit(). Just pass it along to the upper
+250 # layers, where it will be handled.
+251 raise
+252 except Exception:
+253 # Something went wrong while executing the user code.
+254 # Get the exc_info, and pack them into an exception that we can
+255 # throw up to the outer loop. We peel one layer off the traceback
+256 # so that the coverage.py code doesn't appear in the final printed
+257 # traceback.
+258 typ, err, tb = sys.exc_info()
+ +260 # PyPy3 weirdness. If I don't access __context__, then somehow it
+261 # is non-None when the exception is reported at the upper layer,
+262 # and a nested exception is shown to the user. This getattr fixes
+263 # it somehow? https://bitbucket.org/pypy/pypy/issue/1903
+264 getattr(err, '__context__', None)
+ +266 # Call the excepthook.
+267 try:
+268 if hasattr(err, "__traceback__"):
+269 err.__traceback__ = err.__traceback__.tb_next
+270 sys.excepthook(typ, err, tb.tb_next)
+271 except SystemExit: # pylint: disable=try-except-raise
+272 raise
+273 except Exception:
+274 # Getting the output right in the case of excepthook
+275 # shenanigans is kind of involved.
+276 sys.stderr.write("Error in sys.excepthook:\n")
+277 typ2, err2, tb2 = sys.exc_info()
+278 err2.__suppress_context__ = True
+279 if hasattr(err2, "__traceback__"):
+280 err2.__traceback__ = err2.__traceback__.tb_next
+281 sys.__excepthook__(typ2, err2, tb2.tb_next)
+282 sys.stderr.write("\nOriginal exception was:\n")
+283 raise ExceptionDuringRun(typ, err, tb.tb_next)
+284 else:
+285 sys.exit(1)
+286 finally:
+287 os.chdir(cwd)
+ + +290def run_python_module(args):
+291 """Run a Python module, as though with ``python -m name args...``.
+ +293 `args` is the argument array to present as sys.argv, including the first
+294 element naming the module being executed.
+ +296 This is a helper for tests, to encapsulate how to use PyRunner.
+ +298 """
+299 runner = PyRunner(args, as_module=True)
+300 runner.prepare()
+301 runner.run()
+ + +304def run_python_file(args):
+305 """Run a Python file as if it were the main program on the command line.
+ +307 `args` is the argument array to present as sys.argv, including the first
+308 element naming the file being executed. `package` is the name of the
+309 enclosing package, if any.
+ +311 This is a helper for tests, to encapsulate how to use PyRunner.
+ +313 """
+314 runner = PyRunner(args, as_module=False)
+315 runner.prepare()
+316 runner.run()
+ + +319def make_code_from_py(filename):
+320 """Get source from `filename` and make a code object of it."""
+321 # Open the source file.
+322 try:
+323 source = get_python_source(filename)
+324 except (IOError, NoSource):
+325 raise NoSource("No file to run: '%s'" % filename)
+ +327 code = compile_unicode(source, filename, "exec")
+328 return code
+ + +331def make_code_from_pyc(filename):
+332 """Get a code object from a .pyc file."""
+333 try:
+334 fpyc = open(filename, "rb")
+335 except IOError:
+336 raise NoCode("No file to run: '%s'" % filename)
+ +338 with fpyc:
+339 # First four bytes are a version-specific magic number. It has to
+340 # match or we won't run the file.
+341 magic = fpyc.read(4)
+342 if magic != PYC_MAGIC_NUMBER:
+343 raise NoCode("Bad magic number in .pyc file: {} != {}".format(magic, PYC_MAGIC_NUMBER))
+ +345 date_based = True
+346 if env.PYBEHAVIOR.hashed_pyc_pep552:
+347 flags = struct.unpack('<L', fpyc.read(4))[0]
+348 hash_based = flags & 0x01
+349 if hash_based: 349 ↛ 350line 349 didn't jump to line 350, because the condition on line 349 was never true
+350 fpyc.read(8) # Skip the hash.
+351 date_based = False
+352 if date_based: 352 ↛ 360line 352 didn't jump to line 360, because the condition on line 352 was never false
+353 # Skip the junk in the header that we don't need.
+354 fpyc.read(4) # Skip the moddate.
+355 if env.PYBEHAVIOR.size_in_pyc:
+356 # 3.3 added another long to the header (size), skip it.
+357 fpyc.read(4)
+ +359 # The rest of the file is the code object we want.
+360 code = marshal.load(fpyc)
+ +362 return code
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""File wrangling."""
+ +6import hashlib
+7import fnmatch
+8import ntpath
+9import os
+10import os.path
+11import posixpath
+12import re
+13import sys
+ +15from coverage import env
+16from coverage.backward import unicode_class
+17from coverage.misc import contract, CoverageException, join_regex, isolate_module
+ + +20os = isolate_module(os)
+ + +23def set_relative_directory():
+24 """Set the directory that `relative_filename` will be relative to."""
+25 global RELATIVE_DIR, CANONICAL_FILENAME_CACHE
+ +27 # The absolute path to our current directory.
+28 RELATIVE_DIR = os.path.normcase(abs_file(os.curdir) + os.sep)
+ +30 # Cache of results of calling the canonical_filename() method, to
+31 # avoid duplicating work.
+32 CANONICAL_FILENAME_CACHE = {}
+ + +35def relative_directory():
+36 """Return the directory that `relative_filename` is relative to."""
+37 return RELATIVE_DIR
+ + +40@contract(returns='unicode')
+41def relative_filename(filename):
+42 """Return the relative form of `filename`.
+ +44 The file name will be relative to the current directory when the
+45 `set_relative_directory` was called.
+ +47 """
+48 fnorm = os.path.normcase(filename)
+49 if fnorm.startswith(RELATIVE_DIR):
+50 filename = filename[len(RELATIVE_DIR):]
+51 return unicode_filename(filename)
+ + +54@contract(returns='unicode')
+55def canonical_filename(filename):
+56 """Return a canonical file name for `filename`.
+ +58 An absolute path with no redundant components and normalized case.
+ +60 """
+61 if filename not in CANONICAL_FILENAME_CACHE:
+62 cf = filename
+63 if not os.path.isabs(filename):
+64 for path in [os.curdir] + sys.path:
+65 if path is None: 65 ↛ 66line 65 didn't jump to line 66, because the condition on line 65 was never true
+66 continue
+67 f = os.path.join(path, filename)
+68 try:
+69 exists = os.path.exists(f)
+70 except UnicodeError:
+71 exists = False
+72 if exists:
+73 cf = f
+74 break
+75 cf = abs_file(cf)
+76 CANONICAL_FILENAME_CACHE[filename] = cf
+77 return CANONICAL_FILENAME_CACHE[filename]
+ + +80MAX_FLAT = 200
+ +82@contract(filename='unicode', returns='unicode')
+83def flat_rootname(filename):
+84 """A base for a flat file name to correspond to this file.
+ +86 Useful for writing files about the code where you want all the files in
+87 the same directory, but need to differentiate same-named files from
+88 different directories.
+ +90 For example, the file a/b/c.py will return 'a_b_c_py'
+ +92 """
+93 name = ntpath.splitdrive(filename)[1]
+94 name = re.sub(r"[\\/.:]", "_", name)
+95 if len(name) > MAX_FLAT:
+96 h = hashlib.sha1(name.encode('UTF-8')).hexdigest()
+97 name = name[-(MAX_FLAT-len(h)-1):] + '_' + h
+98 return name
+ + +101if env.WINDOWS:
+ +103 _ACTUAL_PATH_CACHE = {}
+104 _ACTUAL_PATH_LIST_CACHE = {}
+ +106 def actual_path(path):
+107 """Get the actual path of `path`, including the correct case."""
+108 if env.PY2 and isinstance(path, unicode_class):
+109 path = path.encode(sys.getfilesystemencoding())
+110 if path in _ACTUAL_PATH_CACHE:
+111 return _ACTUAL_PATH_CACHE[path]
+ +113 head, tail = os.path.split(path)
+114 if not tail:
+115 # This means head is the drive spec: normalize it.
+116 actpath = head.upper()
+117 elif not head: 117 ↛ 118line 117 didn't jump to line 118, because the condition on line 117 was never true
+118 actpath = tail
+119 else:
+120 head = actual_path(head)
+121 if head in _ACTUAL_PATH_LIST_CACHE:
+122 files = _ACTUAL_PATH_LIST_CACHE[head]
+123 else:
+124 try:
+125 files = os.listdir(head)
+126 except Exception:
+127 # This will raise OSError, or this bizarre TypeError:
+128 # https://bugs.python.org/issue1776160
+129 files = []
+130 _ACTUAL_PATH_LIST_CACHE[head] = files
+131 normtail = os.path.normcase(tail)
+132 for f in files:
+133 if os.path.normcase(f) == normtail:
+134 tail = f
+135 break
+136 actpath = os.path.join(head, tail)
+137 _ACTUAL_PATH_CACHE[path] = actpath
+138 return actpath
+ +140else:
+141 def actual_path(filename):
+142 """The actual path for non-Windows platforms."""
+143 return filename
+ + +146if env.PY2:
+147 @contract(returns='unicode')
+148 def unicode_filename(filename):
+149 """Return a Unicode version of `filename`."""
+150 if isinstance(filename, str):
+151 encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
+152 filename = filename.decode(encoding, "replace")
+153 return filename
+154else:
+155 @contract(filename='unicode', returns='unicode')
+156 def unicode_filename(filename):
+157 """Return a Unicode version of `filename`."""
+158 return filename
+ + +161@contract(returns='unicode')
+162def abs_file(path):
+163 """Return the absolute normalized form of `path`."""
+164 try:
+165 path = os.path.realpath(path)
+166 except UnicodeError:
+167 pass
+168 path = os.path.abspath(path)
+169 path = actual_path(path)
+170 path = unicode_filename(path)
+171 return path
+ + +174def python_reported_file(filename):
+175 """Return the string as Python would describe this file name."""
+176 if env.PYBEHAVIOR.report_absolute_files:
+177 filename = os.path.abspath(filename)
+178 return filename
+ + +181RELATIVE_DIR = None
+182CANONICAL_FILENAME_CACHE = None
+183set_relative_directory()
+ + +186def isabs_anywhere(filename):
+187 """Is `filename` an absolute path on any OS?"""
+188 return ntpath.isabs(filename) or posixpath.isabs(filename)
+ + +191def prep_patterns(patterns):
+192 """Prepare the file patterns for use in a `FnmatchMatcher`.
+ +194 If a pattern starts with a wildcard, it is used as a pattern
+195 as-is. If it does not start with a wildcard, then it is made
+196 absolute with the current directory.
+ +198 If `patterns` is None, an empty list is returned.
+ +200 """
+201 prepped = []
+202 for p in patterns or []:
+203 if p.startswith(("*", "?")):
+204 prepped.append(p)
+205 else:
+206 prepped.append(abs_file(p))
+207 return prepped
+ + +210class TreeMatcher(object):
+211 """A matcher for files in a tree.
+ +213 Construct with a list of paths, either files or directories. Paths match
+214 with the `match` method if they are one of the files, or if they are
+215 somewhere in a subtree rooted at one of the directories.
+ +217 """
+218 def __init__(self, paths):
+219 self.paths = list(paths)
+ +221 def __repr__(self):
+222 return "<TreeMatcher %r>" % self.paths
+ +224 def info(self):
+225 """A list of strings for displaying when dumping state."""
+226 return self.paths
+ +228 def match(self, fpath):
+229 """Does `fpath` indicate a file in one of our trees?"""
+230 for p in self.paths:
+231 if fpath.startswith(p):
+232 if fpath == p:
+233 # This is the same file!
+234 return True
+235 if fpath[len(p)] == os.sep:
+236 # This is a file in the directory
+237 return True
+238 return False
+ + +241class ModuleMatcher(object):
+242 """A matcher for modules in a tree."""
+243 def __init__(self, module_names):
+244 self.modules = list(module_names)
+ +246 def __repr__(self):
+247 return "<ModuleMatcher %r>" % (self.modules)
+ +249 def info(self):
+250 """A list of strings for displaying when dumping state."""
+251 return self.modules
+ +253 def match(self, module_name):
+254 """Does `module_name` indicate a module in one of our packages?"""
+255 if not module_name:
+256 return False
+ +258 for m in self.modules:
+259 if module_name.startswith(m):
+260 if module_name == m:
+261 return True
+262 if module_name[len(m)] == '.':
+263 # This is a module in the package
+264 return True
+ +266 return False
+ + +269class FnmatchMatcher(object):
+270 """A matcher for files by file name pattern."""
+271 def __init__(self, pats):
+272 self.pats = list(pats)
+273 self.re = fnmatches_to_regex(self.pats, case_insensitive=env.WINDOWS)
+ +275 def __repr__(self):
+276 return "<FnmatchMatcher %r>" % self.pats
+ +278 def info(self):
+279 """A list of strings for displaying when dumping state."""
+280 return self.pats
+ +282 def match(self, fpath):
+283 """Does `fpath` match one of our file name patterns?"""
+284 return self.re.match(fpath) is not None
+ + +287def sep(s):
+288 """Find the path separator used in this string, or os.sep if none."""
+289 sep_match = re.search(r"[\\/]", s)
+290 if sep_match:
+291 the_sep = sep_match.group(0)
+292 else:
+293 the_sep = os.sep
+294 return the_sep
+ + +297def fnmatches_to_regex(patterns, case_insensitive=False, partial=False):
+298 """Convert fnmatch patterns to a compiled regex that matches any of them.
+ +300 Slashes are always converted to match either slash or backslash, for
+301 Windows support, even when running elsewhere.
+ +303 If `partial` is true, then the pattern will match if the target string
+304 starts with the pattern. Otherwise, it must match the entire string.
+ +306 Returns: a compiled regex object. Use the .match method to compare target
+307 strings.
+ +309 """
+310 regexes = (fnmatch.translate(pattern) for pattern in patterns)
+311 # Python3.7 fnmatch translates "/" as "/". Before that, it translates as "\/",
+312 # so we have to deal with maybe a backslash.
+313 regexes = (re.sub(r"\\?/", r"[\\\\/]", regex) for regex in regexes)
+ +315 if partial:
+316 # fnmatch always adds a \Z to match the whole string, which we don't
+317 # want, so we remove the \Z. While removing it, we only replace \Z if
+318 # followed by paren (introducing flags), or at end, to keep from
+319 # destroying a literal \Z in the pattern.
+320 regexes = (re.sub(r'\\Z(\(\?|$)', r'\1', regex) for regex in regexes)
+ +322 flags = 0
+323 if case_insensitive:
+324 flags |= re.IGNORECASE
+325 compiled = re.compile(join_regex(regexes), flags=flags)
+ +327 return compiled
+ + +330class PathAliases(object):
+331 """A collection of aliases for paths.
+ +333 When combining data files from remote machines, often the paths to source
+334 code are different, for example, due to OS differences, or because of
+335 serialized checkouts on continuous integration machines.
+ +337 A `PathAliases` object tracks a list of pattern/result pairs, and can
+338 map a path through those aliases to produce a unified path.
+ +340 """
+341 def __init__(self):
+342 self.aliases = []
+ +344 def pprint(self): # pragma: debugging
+345 """Dump the important parts of the PathAliases, for debugging."""
+346 for regex, result in self.aliases:
+347 print("{!r} --> {!r}".format(regex.pattern, result))
+ +349 def add(self, pattern, result):
+350 """Add the `pattern`/`result` pair to the list of aliases.
+ +352 `pattern` is an `fnmatch`-style pattern. `result` is a simple
+353 string. When mapping paths, if a path starts with a match against
+354 `pattern`, then that match is replaced with `result`. This models
+355 isomorphic source trees being rooted at different places on two
+356 different machines.
+ +358 `pattern` can't end with a wildcard component, since that would
+359 match an entire tree, and not just its root.
+ +361 """
+362 pattern_sep = sep(pattern)
+ +364 if len(pattern) > 1:
+365 pattern = pattern.rstrip(r"\/")
+ +367 # The pattern can't end with a wildcard component.
+368 if pattern.endswith("*"):
+369 raise CoverageException("Pattern must not end with wildcards.")
+ +371 # The pattern is meant to match a filepath. Let's make it absolute
+372 # unless it already is, or is meant to match any prefix.
+373 if not pattern.startswith('*') and not isabs_anywhere(pattern +
+374 pattern_sep):
+375 pattern = abs_file(pattern)
+376 if not pattern.endswith(pattern_sep):
+377 pattern += pattern_sep
+ +379 # Make a regex from the pattern.
+380 regex = fnmatches_to_regex([pattern], case_insensitive=True, partial=True)
+ +382 # Normalize the result: it must end with a path separator.
+383 result_sep = sep(result)
+384 result = result.rstrip(r"\/") + result_sep
+385 self.aliases.append((regex, result))
+ +387 def map(self, path):
+388 """Map `path` through the aliases.
+ +390 `path` is checked against all of the patterns. The first pattern to
+391 match is used to replace the root of the path with the result root.
+392 Only one pattern is ever used. If no patterns match, `path` is
+393 returned unchanged.
+ +395 The separator style in the result is made to match that of the result
+396 in the alias.
+ +398 Returns the mapped path. If a mapping has happened, this is a
+399 canonical path. If no mapping has happened, it is the original value
+400 of `path` unchanged.
+ +402 """
+403 for regex, result in self.aliases:
+404 m = regex.match(path)
+405 if m:
+406 new = path.replace(m.group(0), result)
+407 new = new.replace(sep(path), sep(result))
+408 new = canonical_filename(new)
+409 return new
+410 return path
+ + +413def find_python_files(dirname):
+414 """Yield all of the importable Python files in `dirname`, recursively.
+ +416 To be importable, the files have to be in a directory with a __init__.py,
+417 except for `dirname` itself, which isn't required to have one. The
+418 assumption is that `dirname` was specified directly, so the user knows
+419 best, but sub-directories are checked for a __init__.py to be sure we only
+420 find the importable files.
+ +422 """
+423 for i, (dirpath, dirnames, filenames) in enumerate(os.walk(dirname)):
+424 if i > 0 and '__init__.py' not in filenames:
+425 # If a directory doesn't have __init__.py, then it isn't
+426 # importable and neither are its files
+427 del dirnames[:]
+428 continue
+429 for filename in filenames:
+430 # We're only interested in files that look like reasonable Python
+431 # files: Must end with .py or .pyw, and must not have certain funny
+432 # characters that probably mean they are editor junk.
+433 if re.match(r"^[^.#~!$@%^&*()+=,]+\.pyw?$", filename):
+434 yield os.path.join(dirpath, filename)
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""HTML reporting for coverage.py."""
+ +6import datetime
+7import json
+8import os
+9import re
+10import shutil
+ +12import coverage
+13from coverage import env
+14from coverage.backward import iitems, SimpleNamespace, format_local_datetime
+15from coverage.data import add_data_to_hash
+16from coverage.files import flat_rootname
+17from coverage.misc import CoverageException, ensure_dir, file_be_gone, Hasher, isolate_module
+18from coverage.report import get_analysis_to_report
+19from coverage.results import Numbers
+20from coverage.templite import Templite
+ +22os = isolate_module(os)
+ + +25# Static files are looked for in a list of places.
+26STATIC_PATH = [
+27 # The place Debian puts system Javascript libraries.
+28 "/usr/share/javascript",
+ +30 # Our htmlfiles directory.
+31 os.path.join(os.path.dirname(__file__), "htmlfiles"),
+32]
+ + +35def data_filename(fname, pkgdir=""):
+36 """Return the path to a data file of ours.
+ +38 The file is searched for on `STATIC_PATH`, and the first place it's found,
+39 is returned.
+ +41 Each directory in `STATIC_PATH` is searched as-is, and also, if `pkgdir`
+42 is provided, at that sub-directory.
+ +44 """
+45 tried = []
+46 for static_dir in STATIC_PATH:
+47 static_filename = os.path.join(static_dir, fname)
+48 if os.path.exists(static_filename):
+49 return static_filename
+50 else:
+51 tried.append(static_filename)
+52 if pkgdir:
+53 static_filename = os.path.join(static_dir, pkgdir, fname)
+54 if os.path.exists(static_filename):
+55 return static_filename
+56 else:
+57 tried.append(static_filename)
+58 raise CoverageException(
+59 "Couldn't find static file %r from %r, tried: %r" % (fname, os.getcwd(), tried)
+60 )
+ + +63def read_data(fname):
+64 """Return the contents of a data file of ours."""
+65 with open(data_filename(fname)) as data_file:
+66 return data_file.read()
+ + +69def write_html(fname, html):
+70 """Write `html` to `fname`, properly encoded."""
+71 html = re.sub(r"(\A\s+)|(\s+$)", "", html, flags=re.MULTILINE) + "\n"
+72 with open(fname, "wb") as fout:
+73 fout.write(html.encode('ascii', 'xmlcharrefreplace'))
+ + +76class HtmlDataGeneration(object):
+77 """Generate structured data to be turned into HTML reports."""
+ +79 EMPTY = "(empty)"
+ +81 def __init__(self, cov):
+82 self.coverage = cov
+83 self.config = self.coverage.config
+84 data = self.coverage.get_data()
+85 self.has_arcs = data.has_arcs()
+86 if self.config.show_contexts:
+87 if data.measured_contexts() == {""}:
+88 self.coverage._warn("No contexts were measured")
+89 data.set_query_contexts(self.config.report_contexts)
+ +91 def data_for_file(self, fr, analysis):
+92 """Produce the data needed for one file's report."""
+93 if self.has_arcs:
+94 missing_branch_arcs = analysis.missing_branch_arcs()
+95 arcs_executed = analysis.arcs_executed()
+ +97 if self.config.show_contexts:
+98 contexts_by_lineno = analysis.data.contexts_by_lineno(analysis.filename)
+ +100 lines = []
+ +102 for lineno, tokens in enumerate(fr.source_token_lines(), start=1):
+103 # Figure out how to mark this line.
+104 category = None
+105 short_annotations = []
+106 long_annotations = []
+ +108 if lineno in analysis.excluded:
+109 category = 'exc'
+110 elif lineno in analysis.missing:
+111 category = 'mis'
+112 elif self.has_arcs and lineno in missing_branch_arcs:
+113 category = 'par'
+114 for b in missing_branch_arcs[lineno]:
+115 if b < 0:
+116 short_annotations.append("exit")
+117 else:
+118 short_annotations.append(b)
+119 long_annotations.append(fr.missing_arc_description(lineno, b, arcs_executed))
+120 elif lineno in analysis.statements:
+121 category = 'run'
+ +123 contexts = contexts_label = None
+124 context_list = None
+125 if category and self.config.show_contexts:
+126 contexts = sorted(c or self.EMPTY for c in contexts_by_lineno[lineno])
+127 if contexts == [self.EMPTY]:
+128 contexts_label = self.EMPTY
+129 else:
+130 contexts_label = "{} ctx".format(len(contexts))
+131 context_list = contexts
+ +133 lines.append(SimpleNamespace(
+134 tokens=tokens,
+135 number=lineno,
+136 category=category,
+137 statement=(lineno in analysis.statements),
+138 contexts=contexts,
+139 contexts_label=contexts_label,
+140 context_list=context_list,
+141 short_annotations=short_annotations,
+142 long_annotations=long_annotations,
+143 ))
+ +145 file_data = SimpleNamespace(
+146 relative_filename=fr.relative_filename(),
+147 nums=analysis.numbers,
+148 lines=lines,
+149 )
+ +151 return file_data
+ + +154class HtmlReporter(object):
+155 """HTML reporting."""
+ +157 # These files will be copied from the htmlfiles directory to the output
+158 # directory.
+159 STATIC_FILES = [
+160 ("style.css", ""),
+161 ("jquery.min.js", "jquery"),
+162 ("jquery.ba-throttle-debounce.min.js", "jquery-throttle-debounce"),
+163 ("jquery.hotkeys.js", "jquery-hotkeys"),
+164 ("jquery.isonscreen.js", "jquery-isonscreen"),
+165 ("jquery.tablesorter.min.js", "jquery-tablesorter"),
+166 ("coverage_html.js", ""),
+167 ("keybd_closed.png", ""),
+168 ("keybd_open.png", ""),
+169 ("favicon_32.png", ""),
+170 ]
+ +172 def __init__(self, cov):
+173 self.coverage = cov
+174 self.config = self.coverage.config
+175 self.directory = self.config.html_dir
+ +177 self.skip_covered = self.config.html_skip_covered
+178 if self.skip_covered is None:
+179 self.skip_covered = self.config.skip_covered
+180 self.skip_empty = self.config.html_skip_empty
+181 if self.skip_empty is None:
+182 self.skip_empty= self.config.skip_empty
+ +184 title = self.config.html_title
+185 if env.PY2:
+186 title = title.decode("utf8")
+ +188 if self.config.extra_css:
+189 self.extra_css = os.path.basename(self.config.extra_css)
+190 else:
+191 self.extra_css = None
+ +193 self.data = self.coverage.get_data()
+194 self.has_arcs = self.data.has_arcs()
+ +196 self.file_summaries = []
+197 self.all_files_nums = []
+198 self.incr = IncrementalChecker(self.directory)
+199 self.datagen = HtmlDataGeneration(self.coverage)
+200 self.totals = Numbers()
+ +202 self.template_globals = {
+203 # Functions available in the templates.
+204 'escape': escape,
+205 'pair': pair,
+206 'len': len,
+ +208 # Constants for this report.
+209 '__url__': coverage.__url__,
+210 '__version__': coverage.__version__,
+211 'title': title,
+212 'time_stamp': format_local_datetime(datetime.datetime.now()),
+213 'extra_css': self.extra_css,
+214 'has_arcs': self.has_arcs,
+215 'show_contexts': self.config.show_contexts,
+ +217 # Constants for all reports.
+218 # These css classes determine which lines are highlighted by default.
+219 'category': {
+220 'exc': 'exc show_exc',
+221 'mis': 'mis show_mis',
+222 'par': 'par run show_par',
+223 'run': 'run',
+224 }
+225 }
+226 self.pyfile_html_source = read_data("pyfile.html")
+227 self.source_tmpl = Templite(self.pyfile_html_source, self.template_globals)
+ +229 def report(self, morfs):
+230 """Generate an HTML report for `morfs`.
+ +232 `morfs` is a list of modules or file names.
+ +234 """
+235 # Read the status data and check that this run used the same
+236 # global data as the last run.
+237 self.incr.read()
+238 self.incr.check_global_data(self.config, self.pyfile_html_source)
+ +240 # Process all the files.
+241 for fr, analysis in get_analysis_to_report(self.coverage, morfs):
+242 self.html_file(fr, analysis)
+ +244 if not self.all_files_nums:
+245 raise CoverageException("No data to report.")
+ +247 self.totals = sum(self.all_files_nums)
+ +249 # Write the index file.
+250 self.index_file()
+ +252 self.make_local_static_report_files()
+253 return self.totals.n_statements and self.totals.pc_covered
+ +255 def make_local_static_report_files(self):
+256 """Make local instances of static files for HTML report."""
+257 # The files we provide must always be copied.
+258 for static, pkgdir in self.STATIC_FILES:
+259 shutil.copyfile(
+260 data_filename(static, pkgdir),
+261 os.path.join(self.directory, static)
+262 )
+ +264 # The user may have extra CSS they want copied.
+265 if self.extra_css:
+266 shutil.copyfile(
+267 self.config.extra_css,
+268 os.path.join(self.directory, self.extra_css)
+269 )
+ +271 def html_file(self, fr, analysis):
+272 """Generate an HTML file for one source file."""
+273 rootname = flat_rootname(fr.relative_filename())
+274 html_filename = rootname + ".html"
+275 ensure_dir(self.directory)
+276 html_path = os.path.join(self.directory, html_filename)
+ +278 # Get the numbers for this file.
+279 nums = analysis.numbers
+280 self.all_files_nums.append(nums)
+ +282 if self.skip_covered:
+283 # Don't report on 100% files.
+284 no_missing_lines = (nums.n_missing == 0)
+285 no_missing_branches = (nums.n_partial_branches == 0)
+286 if no_missing_lines and no_missing_branches:
+287 # If there's an existing file, remove it.
+288 file_be_gone(html_path)
+289 return
+ +291 if self.skip_empty:
+292 # Don't report on empty files.
+293 if nums.n_statements == 0:
+294 file_be_gone(html_path)
+295 return
+ +297 # Find out if the file on disk is already correct.
+298 if self.incr.can_skip_file(self.data, fr, rootname):
+299 self.file_summaries.append(self.incr.index_info(rootname))
+300 return
+ +302 # Write the HTML page for this file.
+303 file_data = self.datagen.data_for_file(fr, analysis)
+304 for ldata in file_data.lines:
+305 # Build the HTML for the line.
+306 html = []
+307 for tok_type, tok_text in ldata.tokens:
+308 if tok_type == "ws":
+309 html.append(escape(tok_text))
+310 else:
+311 tok_html = escape(tok_text) or ' '
+312 html.append(
+313 u'<span class="{}">{}</span>'.format(tok_type, tok_html)
+314 )
+315 ldata.html = ''.join(html)
+ +317 if ldata.short_annotations:
+318 # 202F is NARROW NO-BREAK SPACE.
+319 # 219B is RIGHTWARDS ARROW WITH STROKE.
+320 ldata.annotate = u", ".join(
+321 u"{} ↛ {}".format(ldata.number, d)
+322 for d in ldata.short_annotations
+323 )
+324 else:
+325 ldata.annotate = None
+ +327 if ldata.long_annotations:
+328 longs = ldata.long_annotations
+329 if len(longs) == 1:
+330 ldata.annotate_long = longs[0]
+331 else:
+332 ldata.annotate_long = u"{:d} missed branches: {}".format(
+333 len(longs),
+334 u", ".join(
+335 u"{:d}) {}".format(num, ann_long)
+336 for num, ann_long in enumerate(longs, start=1)
+337 ),
+338 )
+339 else:
+340 ldata.annotate_long = None
+ +342 css_classes = []
+343 if ldata.category:
+344 css_classes.append(self.template_globals['category'][ldata.category])
+345 ldata.css_class = ' '.join(css_classes) or "pln"
+ +347 html = self.source_tmpl.render(file_data.__dict__)
+348 write_html(html_path, html)
+ +350 # Save this file's information for the index file.
+351 index_info = {
+352 'nums': nums,
+353 'html_filename': html_filename,
+354 'relative_filename': fr.relative_filename(),
+355 }
+356 self.file_summaries.append(index_info)
+357 self.incr.set_index_info(rootname, index_info)
+ +359 def index_file(self):
+360 """Write the index.html file for this report."""
+361 index_tmpl = Templite(read_data("index.html"), self.template_globals)
+ +363 html = index_tmpl.render({
+364 'files': self.file_summaries,
+365 'totals': self.totals,
+366 })
+ +368 write_html(os.path.join(self.directory, "index.html"), html)
+ +370 # Write the latest hashes for next time.
+371 self.incr.write()
+ + +374class IncrementalChecker(object):
+375 """Logic and data to support incremental reporting."""
+ +377 STATUS_FILE = "status.json"
+378 STATUS_FORMAT = 2
+ +380 # pylint: disable=wrong-spelling-in-comment,useless-suppression
+381 # The data looks like:
+382 #
+383 # {
+384 # "format": 2,
+385 # "globals": "540ee119c15d52a68a53fe6f0897346d",
+386 # "version": "4.0a1",
+387 # "files": {
+388 # "cogapp___init__": {
+389 # "hash": "e45581a5b48f879f301c0f30bf77a50c",
+390 # "index": {
+391 # "html_filename": "cogapp___init__.html",
+392 # "relative_filename": "cogapp/__init__",
+393 # "nums": [ 1, 14, 0, 0, 0, 0, 0 ]
+394 # }
+395 # },
+396 # ...
+397 # "cogapp_whiteutils": {
+398 # "hash": "8504bb427fc488c4176809ded0277d51",
+399 # "index": {
+400 # "html_filename": "cogapp_whiteutils.html",
+401 # "relative_filename": "cogapp/whiteutils",
+402 # "nums": [ 1, 59, 0, 1, 28, 2, 2 ]
+403 # }
+404 # }
+405 # }
+406 # }
+ +408 def __init__(self, directory):
+409 self.directory = directory
+410 self.reset()
+ +412 def reset(self):
+413 """Initialize to empty. Causes all files to be reported."""
+414 self.globals = ''
+415 self.files = {}
+ +417 def read(self):
+418 """Read the information we stored last time."""
+419 usable = False
+420 try:
+421 status_file = os.path.join(self.directory, self.STATUS_FILE)
+422 with open(status_file) as fstatus:
+423 status = json.load(fstatus)
+424 except (IOError, ValueError):
+425 usable = False
+426 else:
+427 usable = True
+428 if status['format'] != self.STATUS_FORMAT:
+429 usable = False
+430 elif status['version'] != coverage.__version__:
+431 usable = False
+ +433 if usable:
+434 self.files = {}
+435 for filename, fileinfo in iitems(status['files']):
+436 fileinfo['index']['nums'] = Numbers(*fileinfo['index']['nums'])
+437 self.files[filename] = fileinfo
+438 self.globals = status['globals']
+439 else:
+440 self.reset()
+ +442 def write(self):
+443 """Write the current status."""
+444 status_file = os.path.join(self.directory, self.STATUS_FILE)
+445 files = {}
+446 for filename, fileinfo in iitems(self.files):
+447 fileinfo['index']['nums'] = fileinfo['index']['nums'].init_args()
+448 files[filename] = fileinfo
+ +450 status = {
+451 'format': self.STATUS_FORMAT,
+452 'version': coverage.__version__,
+453 'globals': self.globals,
+454 'files': files,
+455 }
+456 with open(status_file, "w") as fout:
+457 json.dump(status, fout, separators=(',', ':'))
+ +459 def check_global_data(self, *data):
+460 """Check the global data that can affect incremental reporting."""
+461 m = Hasher()
+462 for d in data:
+463 m.update(d)
+464 these_globals = m.hexdigest()
+465 if self.globals != these_globals:
+466 self.reset()
+467 self.globals = these_globals
+ +469 def can_skip_file(self, data, fr, rootname):
+470 """Can we skip reporting this file?
+ +472 `data` is a CoverageData object, `fr` is a `FileReporter`, and
+473 `rootname` is the name being used for the file.
+474 """
+475 m = Hasher()
+476 m.update(fr.source().encode('utf-8'))
+477 add_data_to_hash(data, fr.filename, m)
+478 this_hash = m.hexdigest()
+ +480 that_hash = self.file_hash(rootname)
+ +482 if this_hash == that_hash:
+483 # Nothing has changed to require the file to be reported again.
+484 return True
+485 else:
+486 self.set_file_hash(rootname, this_hash)
+487 return False
+ +489 def file_hash(self, fname):
+490 """Get the hash of `fname`'s contents."""
+491 return self.files.get(fname, {}).get('hash', '')
+ +493 def set_file_hash(self, fname, val):
+494 """Set the hash of `fname`'s contents."""
+495 self.files.setdefault(fname, {})['hash'] = val
+ +497 def index_info(self, fname):
+498 """Get the information for index.html for `fname`."""
+499 return self.files.get(fname, {}).get('index', {})
+ +501 def set_index_info(self, fname, info):
+502 """Set the information for index.html for `fname`."""
+503 self.files.setdefault(fname, {})['index'] = info
+ + +506# Helpers for templates and generating HTML
+ +508def escape(t):
+509 """HTML-escape the text in `t`.
+ +511 This is only suitable for HTML text, not attributes.
+ +513 """
+514 # Convert HTML special chars into HTML entities.
+515 return t.replace("&", "&").replace("<", "<")
+ + +518def pair(ratio):
+519 """Format a pair of numbers so JavaScript can read them in an attribute."""
+520 return "%s %s" % ratio
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Determining whether files are being measured/reported or not."""
+ +6# For finding the stdlib
+7import atexit
+8import inspect
+9import itertools
+10import os
+11import platform
+12import re
+13import sys
+14import traceback
+ +16from coverage import env
+17from coverage.backward import code_object
+18from coverage.disposition import FileDisposition, disposition_init
+19from coverage.files import TreeMatcher, FnmatchMatcher, ModuleMatcher
+20from coverage.files import prep_patterns, find_python_files, canonical_filename
+21from coverage.misc import CoverageException
+22from coverage.python import source_for_file, source_for_morf
+ + +25# Pypy has some unusual stuff in the "stdlib". Consider those locations
+26# when deciding where the stdlib is. These modules are not used for anything,
+27# they are modules importable from the pypy lib directories, so that we can
+28# find those directories.
+29_structseq = _pypy_irc_topic = None
+30if env.PYPY:
+31 try:
+32 import _structseq
+33 except ImportError:
+34 pass
+ +36 try:
+37 import _pypy_irc_topic
+38 except ImportError:
+39 pass
+ + +42def canonical_path(morf, directory=False):
+43 """Return the canonical path of the module or file `morf`.
+ +45 If the module is a package, then return its directory. If it is a
+46 module, then return its file, unless `directory` is True, in which
+47 case return its enclosing directory.
+ +49 """
+50 morf_path = canonical_filename(source_for_morf(morf))
+51 if morf_path.endswith("__init__.py") or directory:
+52 morf_path = os.path.split(morf_path)[0]
+53 return morf_path
+ + +56def name_for_module(filename, frame):
+57 """Get the name of the module for a filename and frame.
+ +59 For configurability's sake, we allow __main__ modules to be matched by
+60 their importable name.
+ +62 If loaded via runpy (aka -m), we can usually recover the "original"
+63 full dotted module name, otherwise, we resort to interpreting the
+64 file name to get the module's name. In the case that the module name
+65 can't be determined, None is returned.
+ +67 """
+68 module_globals = frame.f_globals if frame is not None else {}
+69 if module_globals is None: # pragma: only ironpython
+70 # IronPython doesn't provide globals: https://github.com/IronLanguages/main/issues/1296
+71 module_globals = {}
+ +73 dunder_name = module_globals.get('__name__', None)
+ +75 if isinstance(dunder_name, str) and dunder_name != '__main__': 75 ↛ 77line 75 didn't jump to line 77, because the condition on line 75 was never true
+76 # This is the usual case: an imported module.
+77 return dunder_name
+ +79 loader = module_globals.get('__loader__', None)
+80 for attrname in ('fullname', 'name'): # attribute renamed in py3.2
+81 if hasattr(loader, attrname): 81 ↛ 82line 81 didn't jump to line 82, because the condition on line 81 was never true
+82 fullname = getattr(loader, attrname)
+83 else:
+84 continue
+ +86 if isinstance(fullname, str) and fullname != '__main__':
+87 # Module loaded via: runpy -m
+88 return fullname
+ +90 # Script as first argument to Python command line.
+91 inspectedname = inspect.getmodulename(filename)
+92 if inspectedname is not None:
+93 return inspectedname
+94 else:
+95 return dunder_name
+ + +98def module_is_namespace(mod):
+99 """Is the module object `mod` a PEP420 namespace module?"""
+100 return hasattr(mod, '__path__') and getattr(mod, '__file__', None) is None
+ + +103def module_has_file(mod):
+104 """Does the module object `mod` have an existing __file__ ?"""
+105 mod__file__ = getattr(mod, '__file__', None)
+106 if mod__file__ is None:
+107 return False
+108 return os.path.exists(mod__file__)
+ + +111class InOrOut(object):
+112 """Machinery for determining what files to measure."""
+ +114 def __init__(self, warn, debug):
+115 self.warn = warn
+116 self.debug = debug
+ +118 # The matchers for should_trace.
+119 self.source_match = None
+120 self.source_pkgs_match = None
+121 self.pylib_paths = self.cover_paths = None
+122 self.pylib_match = self.cover_match = None
+123 self.include_match = self.omit_match = None
+124 self.plugins = []
+125 self.disp_class = FileDisposition
+ +127 # The source argument can be directories or package names.
+128 self.source = []
+129 self.source_pkgs = []
+130 self.source_pkgs_unmatched = []
+131 self.omit = self.include = None
+ +133 def configure(self, config):
+134 """Apply the configuration to get ready for decision-time."""
+135 self.source_pkgs.extend(config.source_pkgs)
+136 for src in config.source or []:
+137 if os.path.isdir(src):
+138 self.source.append(canonical_filename(src))
+139 else:
+140 self.source_pkgs.append(src)
+141 self.source_pkgs_unmatched = self.source_pkgs[:]
+ +143 self.omit = prep_patterns(config.run_omit)
+144 self.include = prep_patterns(config.run_include)
+ +146 # The directories for files considered "installed with the interpreter".
+147 self.pylib_paths = set()
+148 if not config.cover_pylib:
+149 # Look at where some standard modules are located. That's the
+150 # indication for "installed with the interpreter". In some
+151 # environments (virtualenv, for example), these modules may be
+152 # spread across a few locations. Look at all the candidate modules
+153 # we've imported, and take all the different ones.
+154 for m in (atexit, inspect, os, platform, _pypy_irc_topic, re, _structseq, traceback):
+155 if m is not None and hasattr(m, "__file__"):
+156 self.pylib_paths.add(canonical_path(m, directory=True))
+ +158 if _structseq and not hasattr(_structseq, '__file__'):
+159 # PyPy 2.4 has no __file__ in the builtin modules, but the code
+160 # objects still have the file names. So dig into one to find
+161 # the path to exclude. The "filename" might be synthetic,
+162 # don't be fooled by those.
+163 structseq_file = code_object(_structseq.structseq_new).co_filename
+164 if not structseq_file.startswith("<"): 164 ↛ 165line 164 didn't jump to line 165, because the condition on line 164 was never true
+165 self.pylib_paths.add(canonical_path(structseq_file))
+ +167 # To avoid tracing the coverage.py code itself, we skip anything
+168 # located where we are.
+169 self.cover_paths = [canonical_path(__file__, directory=True)]
+170 if env.TESTING:
+171 # Don't include our own test code.
+172 self.cover_paths.append(os.path.join(self.cover_paths[0], "tests"))
+ +174 # When testing, we use PyContracts, which should be considered
+175 # part of coverage.py, and it uses six. Exclude those directories
+176 # just as we exclude ourselves.
+177 import contracts
+178 import six
+179 for mod in [contracts, six]:
+180 self.cover_paths.append(canonical_path(mod))
+ +182 def debug(msg):
+183 if self.debug:
+184 self.debug.write(msg)
+ +186 # Create the matchers we need for should_trace
+187 if self.source or self.source_pkgs:
+188 against = []
+189 if self.source:
+190 self.source_match = TreeMatcher(self.source)
+191 against.append("trees {!r}".format(self.source_match))
+192 if self.source_pkgs:
+193 self.source_pkgs_match = ModuleMatcher(self.source_pkgs)
+194 against.append("modules {!r}".format(self.source_pkgs_match))
+195 debug("Source matching against " + " and ".join(against))
+196 else:
+197 if self.cover_paths: 197 ↛ 200line 197 didn't jump to line 200, because the condition on line 197 was never false
+198 self.cover_match = TreeMatcher(self.cover_paths)
+199 debug("Coverage code matching: {!r}".format(self.cover_match))
+200 if self.pylib_paths:
+201 self.pylib_match = TreeMatcher(self.pylib_paths)
+202 debug("Python stdlib matching: {!r}".format(self.pylib_match))
+203 if self.include:
+204 self.include_match = FnmatchMatcher(self.include)
+205 debug("Include matching: {!r}".format(self.include_match))
+206 if self.omit:
+207 self.omit_match = FnmatchMatcher(self.omit)
+208 debug("Omit matching: {!r}".format(self.omit_match))
+ +210 def should_trace(self, filename, frame=None):
+211 """Decide whether to trace execution in `filename`, with a reason.
+ +213 This function is called from the trace function. As each new file name
+214 is encountered, this function determines whether it is traced or not.
+ +216 Returns a FileDisposition object.
+ +218 """
+219 original_filename = filename
+220 disp = disposition_init(self.disp_class, filename)
+ +222 def nope(disp, reason):
+223 """Simple helper to make it easy to return NO."""
+224 disp.trace = False
+225 disp.reason = reason
+226 return disp
+ +228 if frame is not None: 228 ↛ 235line 228 didn't jump to line 235, because the condition on line 228 was never true
+229 # Compiled Python files have two file names: frame.f_code.co_filename is
+230 # the file name at the time the .pyc was compiled. The second name is
+231 # __file__, which is where the .pyc was actually loaded from. Since
+232 # .pyc files can be moved after compilation (for example, by being
+233 # installed), we look for __file__ in the frame and prefer it to the
+234 # co_filename value.
+235 dunder_file = frame.f_globals and frame.f_globals.get('__file__')
+236 if dunder_file:
+237 filename = source_for_file(dunder_file)
+238 if original_filename and not original_filename.startswith('<'):
+239 orig = os.path.basename(original_filename)
+240 if orig != os.path.basename(filename):
+241 # Files shouldn't be renamed when moved. This happens when
+242 # exec'ing code. If it seems like something is wrong with
+243 # the frame's file name, then just use the original.
+244 filename = original_filename
+ +246 if not filename: 246 ↛ 248line 246 didn't jump to line 248, because the condition on line 246 was never true
+247 # Empty string is pretty useless.
+248 return nope(disp, "empty string isn't a file name")
+ +250 if filename.startswith('memory:'): 250 ↛ 251line 250 didn't jump to line 251, because the condition on line 250 was never true
+251 return nope(disp, "memory isn't traceable")
+ +253 if filename.startswith('<'): 253 ↛ 258line 253 didn't jump to line 258, because the condition on line 253 was never true
+254 # Lots of non-file execution is represented with artificial
+255 # file names like "<string>", "<doctest readme.txt[0]>", or
+256 # "<exec_function>". Don't ever trace these executions, since we
+257 # can't do anything with the data later anyway.
+258 return nope(disp, "not a real file name")
+ +260 # pyexpat does a dumb thing, calling the trace function explicitly from
+261 # C code with a C file name.
+262 if re.search(r"[/\\]Modules[/\\]pyexpat.c", filename): 262 ↛ 263line 262 didn't jump to line 263, because the condition on line 262 was never true
+263 return nope(disp, "pyexpat lies about itself")
+ +265 # Jython reports the .class file to the tracer, use the source file.
+266 if filename.endswith("$py.class"): 266 ↛ 267line 266 didn't jump to line 267, because the condition on line 266 was never true
+267 filename = filename[:-9] + ".py"
+ +269 canonical = canonical_filename(filename)
+270 disp.canonical_filename = canonical
+ +272 # Try the plugins, see if they have an opinion about the file.
+273 plugin = None
+274 for plugin in self.plugins.file_tracers: 274 ↛ 275line 274 didn't jump to line 275, because the loop on line 274 never started
+275 if not plugin._coverage_enabled:
+276 continue
+ +278 try:
+279 file_tracer = plugin.file_tracer(canonical)
+280 if file_tracer is not None:
+281 file_tracer._coverage_plugin = plugin
+282 disp.trace = True
+283 disp.file_tracer = file_tracer
+284 if file_tracer.has_dynamic_source_filename():
+285 disp.has_dynamic_filename = True
+286 else:
+287 disp.source_filename = canonical_filename(
+288 file_tracer.source_filename()
+289 )
+290 break
+291 except Exception:
+292 self.warn(
+293 "Disabling plug-in %r due to an exception:" % (plugin._coverage_plugin_name)
+294 )
+295 traceback.print_exc()
+296 plugin._coverage_enabled = False
+297 continue
+298 else:
+299 # No plugin wanted it: it's Python.
+300 disp.trace = True
+301 disp.source_filename = canonical
+ +303 if not disp.has_dynamic_filename: 303 ↛ 313line 303 didn't jump to line 313, because the condition on line 303 was never false
+304 if not disp.source_filename: 304 ↛ 305line 304 didn't jump to line 305, because the condition on line 304 was never true
+305 raise CoverageException(
+306 "Plugin %r didn't set source_filename for %r" %
+307 (plugin, disp.original_filename)
+308 )
+309 reason = self.check_include_omit_etc(disp.source_filename, frame)
+310 if reason:
+311 nope(disp, reason)
+ +313 return disp
+ +315 def check_include_omit_etc(self, filename, frame):
+316 """Check a file name against the include, omit, etc, rules.
+ +318 Returns a string or None. String means, don't trace, and is the reason
+319 why. None means no reason found to not trace.
+ +321 """
+322 modulename = name_for_module(filename, frame)
+ +324 # If the user specified source or include, then that's authoritative
+325 # about the outer bound of what to measure and we don't have to apply
+326 # any canned exclusions. If they didn't, then we have to exclude the
+327 # stdlib and coverage.py directories.
+328 if self.source_match or self.source_pkgs_match:
+329 extra = ""
+330 ok = False
+331 if self.source_pkgs_match:
+332 if self.source_pkgs_match.match(modulename): 332 ↛ 333line 332 didn't jump to line 333, because the condition on line 332 was never true
+333 ok = True
+334 if modulename in self.source_pkgs_unmatched:
+335 self.source_pkgs_unmatched.remove(modulename)
+336 else:
+337 extra = "module {!r} ".format(modulename)
+338 if not ok and self.source_match:
+339 if self.source_match.match(filename): 339 ↛ 340line 339 didn't jump to line 340, because the condition on line 339 was never true
+340 ok = True
+341 if not ok: 341 ↛ 358line 341 didn't jump to line 358, because the condition on line 341 was never false
+342 return extra + "falls outside the --source spec"
+343 elif self.include_match: 343 ↛ 349line 343 didn't jump to line 349, because the condition on line 343 was never false
+344 if not self.include_match.match(filename):
+345 return "falls outside the --include trees"
+346 else:
+347 # If we aren't supposed to trace installed code, then check if this
+348 # is near the Python standard library and skip it if so.
+349 if self.pylib_match and self.pylib_match.match(filename):
+350 return "is in the stdlib"
+ +352 # We exclude the coverage.py code itself, since a little of it
+353 # will be measured otherwise.
+354 if self.cover_match and self.cover_match.match(filename):
+355 return "is part of coverage.py"
+ +357 # Check the file against the omit pattern.
+358 if self.omit_match and self.omit_match.match(filename): 358 ↛ 359line 358 didn't jump to line 359, because the condition on line 358 was never true
+359 return "is inside an --omit pattern"
+ +361 # No point tracing a file we can't later write to SQLite.
+362 try:
+363 filename.encode("utf8")
+364 except UnicodeEncodeError:
+365 return "non-encodable filename"
+ +367 # No reason found to skip this file.
+368 return None
+ +370 def warn_conflicting_settings(self):
+371 """Warn if there are settings that conflict."""
+372 if self.include:
+373 if self.source or self.source_pkgs:
+374 self.warn("--include is ignored because --source is set", slug="include-ignored")
+ +376 def warn_already_imported_files(self):
+377 """Warn if files have already been imported that we will be measuring."""
+378 if self.include or self.source or self.source_pkgs:
+379 warned = set()
+380 for mod in list(sys.modules.values()):
+381 filename = getattr(mod, "__file__", None)
+382 if filename is None:
+383 continue
+384 if filename in warned: 384 ↛ 385line 384 didn't jump to line 385, because the condition on line 384 was never true
+385 continue
+ +387 disp = self.should_trace(filename)
+388 if disp.trace:
+389 msg = "Already imported a file that will be measured: {}".format(filename)
+390 self.warn(msg, slug="already-imported")
+391 warned.add(filename)
+ +393 def warn_unimported_source(self):
+394 """Warn about source packages that were of interest, but never traced."""
+395 for pkg in self.source_pkgs_unmatched:
+396 self._warn_about_unmeasured_code(pkg)
+ +398 def _warn_about_unmeasured_code(self, pkg):
+399 """Warn about a package or module that we never traced.
+ +401 `pkg` is a string, the name of the package or module.
+ +403 """
+404 mod = sys.modules.get(pkg)
+405 if mod is None:
+406 self.warn("Module %s was never imported." % pkg, slug="module-not-imported")
+407 return
+ +409 if module_is_namespace(mod):
+410 # A namespace package. It's OK for this not to have been traced,
+411 # since there is no code directly in it.
+412 return
+ +414 if not module_has_file(mod):
+415 self.warn("Module %s has no Python source." % pkg, slug="module-not-python")
+416 return
+ +418 # The module was in sys.modules, and seems like a module with code, but
+419 # we never measured it. I guess that means it was imported before
+420 # coverage even started.
+421 self.warn(
+422 "Module %s was previously imported, but not measured" % pkg,
+423 slug="module-not-measured",
+424 )
+ +426 def find_possibly_unexecuted_files(self):
+427 """Find files in the areas of interest that might be untraced.
+ +429 Yields pairs: file path, and responsible plug-in name.
+430 """
+431 for pkg in self.source_pkgs:
+432 if (not pkg in sys.modules or
+433 not module_has_file(sys.modules[pkg])):
+434 continue
+435 pkg_file = source_for_file(sys.modules[pkg].__file__)
+436 for ret in self._find_executable_files(canonical_path(pkg_file)):
+437 yield ret
+ +439 for src in self.source:
+440 for ret in self._find_executable_files(src):
+441 yield ret
+ +443 def _find_plugin_files(self, src_dir):
+444 """Get executable files from the plugins."""
+445 for plugin in self.plugins.file_tracers:
+446 for x_file in plugin.find_executable_files(src_dir):
+447 yield x_file, plugin._coverage_plugin_name
+ +449 def _find_executable_files(self, src_dir):
+450 """Find executable files in `src_dir`.
+ +452 Search for files in `src_dir` that can be executed because they
+453 are probably importable. Don't include ones that have been omitted
+454 by the configuration.
+ +456 Yield the file path, and the plugin name that handles the file.
+ +458 """
+459 py_files = ((py_file, None) for py_file in find_python_files(src_dir))
+460 plugin_files = self._find_plugin_files(src_dir)
+ +462 for file_path, plugin_name in itertools.chain(py_files, plugin_files):
+463 file_path = canonical_filename(file_path)
+464 if self.omit_match and self.omit_match.match(file_path):
+465 # Turns out this file was omitted, so don't pull it back
+466 # in as unexecuted.
+467 continue
+468 yield file_path, plugin_name
+ +470 def sys_info(self):
+471 """Our information for Coverage.sys_info.
+ +473 Returns a list of (key, value) pairs.
+474 """
+475 info = [
+476 ('cover_paths', self.cover_paths),
+477 ('pylib_paths', self.pylib_paths),
+478 ]
+ +480 matcher_names = [
+481 'source_match', 'source_pkgs_match',
+482 'include_match', 'omit_match',
+483 'cover_match', 'pylib_match',
+484 ]
+ +486 for matcher_name in matcher_names:
+487 matcher = getattr(self, matcher_name)
+488 if matcher:
+489 matcher_info = matcher.info()
+490 else:
+491 matcher_info = '-none-'
+492 info.append((matcher_name, matcher_info))
+ +494 return info
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# coding: utf-8
+2# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+3# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +5"""Json reporting for coverage.py"""
+6import datetime
+7import json
+8import sys
+ +10from coverage import __version__
+11from coverage.report import get_analysis_to_report
+12from coverage.results import Numbers
+ + +15class JsonReporter(object):
+16 """A reporter for writing JSON coverage results."""
+ +18 def __init__(self, coverage):
+19 self.coverage = coverage
+20 self.config = self.coverage.config
+21 self.total = Numbers()
+22 self.report_data = {}
+ +24 def report(self, morfs, outfile=None):
+25 """Generate a json report for `morfs`.
+ +27 `morfs` is a list of modules or file names.
+ +29 `outfile` is a file object to write the json to
+ +31 """
+32 outfile = outfile or sys.stdout
+33 coverage_data = self.coverage.get_data()
+34 coverage_data.set_query_contexts(self.config.report_contexts)
+35 self.report_data["meta"] = {
+36 "version": __version__,
+37 "timestamp": datetime.datetime.now().isoformat(),
+38 "branch_coverage": coverage_data.has_arcs(),
+39 "show_contexts": self.config.json_show_contexts,
+40 }
+ +42 measured_files = {}
+43 for file_reporter, analysis in get_analysis_to_report(self.coverage, morfs):
+44 measured_files[file_reporter.relative_filename()] = self.report_one_file(
+45 coverage_data,
+46 analysis
+47 )
+ +49 self.report_data["files"] = measured_files
+ +51 self.report_data["totals"] = {
+52 'covered_lines': self.total.n_executed,
+53 'num_statements': self.total.n_statements,
+54 'percent_covered': self.total.pc_covered,
+55 'percent_covered_display': self.total.pc_covered_str,
+56 'missing_lines': self.total.n_missing,
+57 'excluded_lines': self.total.n_excluded,
+58 }
+ +60 if coverage_data.has_arcs():
+61 self.report_data["totals"].update({
+62 'num_branches': self.total.n_branches,
+63 'num_partial_branches': self.total.n_partial_branches,
+64 'covered_branches': self.total.n_executed_branches,
+65 'missing_branches': self.total.n_missing_branches,
+66 })
+ +68 json.dump(
+69 self.report_data,
+70 outfile,
+71 indent=4 if self.config.json_pretty_print else None
+72 )
+ +74 return self.total.n_statements and self.total.pc_covered
+ +76 def report_one_file(self, coverage_data, analysis):
+77 """Extract the relevant report data for a single file"""
+78 nums = analysis.numbers
+79 self.total += nums
+80 summary = {
+81 'covered_lines': nums.n_executed,
+82 'num_statements': nums.n_statements,
+83 'percent_covered': nums.pc_covered,
+84 'percent_covered_display': nums.pc_covered_str,
+85 'missing_lines': nums.n_missing,
+86 'excluded_lines': nums.n_excluded,
+87 }
+88 reported_file = {
+89 'executed_lines': sorted(analysis.executed),
+90 'summary': summary,
+91 'missing_lines': sorted(analysis.missing),
+92 'excluded_lines': sorted(analysis.excluded)
+93 }
+94 if self.config.json_show_contexts:
+95 reported_file['contexts'] = analysis.data.contexts_by_lineno(
+96 analysis.filename,
+97 )
+98 if coverage_data.has_arcs():
+99 reported_file['summary'].update({
+100 'num_branches': nums.n_branches,
+101 'num_partial_branches': nums.n_partial_branches,
+102 'covered_branches': nums.n_executed_branches,
+103 'missing_branches': nums.n_missing_branches,
+104 })
+105 return reported_file
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Miscellaneous stuff for coverage.py."""
+ +6import errno
+7import hashlib
+8import inspect
+9import locale
+10import os
+11import os.path
+12import random
+13import re
+14import socket
+15import sys
+16import types
+ +18from coverage import env
+19from coverage.backward import to_bytes, unicode_class
+ +21ISOLATED_MODULES = {}
+ + +24def isolate_module(mod):
+25 """Copy a module so that we are isolated from aggressive mocking.
+ +27 If a test suite mocks os.path.exists (for example), and then we need to use
+28 it during the test, everything will get tangled up if we use their mock.
+29 Making a copy of the module when we import it will isolate coverage.py from
+30 those complications.
+31 """
+32 if mod not in ISOLATED_MODULES:
+33 new_mod = types.ModuleType(mod.__name__)
+34 ISOLATED_MODULES[mod] = new_mod
+35 for name in dir(mod):
+36 value = getattr(mod, name)
+37 if isinstance(value, types.ModuleType):
+38 value = isolate_module(value)
+39 setattr(new_mod, name, value)
+40 return ISOLATED_MODULES[mod]
+ +42os = isolate_module(os)
+ + +45def dummy_decorator_with_args(*args_unused, **kwargs_unused):
+46 """Dummy no-op implementation of a decorator with arguments."""
+47 def _decorator(func):
+48 return func
+49 return _decorator
+ + +52# Environment COVERAGE_NO_CONTRACTS=1 can turn off contracts while debugging
+53# tests to remove noise from stack traces.
+54# $set_env.py: COVERAGE_NO_CONTRACTS - Disable PyContracts to simplify stack traces.
+55USE_CONTRACTS = env.TESTING and not bool(int(os.environ.get("COVERAGE_NO_CONTRACTS", 0)))
+ +57# Use PyContracts for assertion testing on parameters and returns, but only if
+58# we are running our own test suite.
+59if USE_CONTRACTS:
+60 from contracts import contract # pylint: disable=unused-import
+61 from contracts import new_contract as raw_new_contract
+ +63 def new_contract(*args, **kwargs):
+64 """A proxy for contracts.new_contract that doesn't mind happening twice."""
+65 try:
+66 raw_new_contract(*args, **kwargs)
+67 except ValueError:
+68 # During meta-coverage, this module is imported twice, and
+69 # PyContracts doesn't like redefining contracts. It's OK.
+70 pass
+ +72 # Define contract words that PyContract doesn't have.
+73 new_contract('bytes', lambda v: isinstance(v, bytes)) 73 ↛ exitline 73 didn't run the lambda on line 73
+74 if env.PY3:
+75 new_contract('unicode', lambda v: isinstance(v, unicode_class)) 75 ↛ exitline 75 didn't run the lambda on line 75
+ +77 def one_of(argnames):
+78 """Ensure that only one of the argnames is non-None."""
+79 def _decorator(func):
+80 argnameset = {name.strip() for name in argnames.split(",")}
+81 def _wrapper(*args, **kwargs):
+82 vals = [kwargs.get(name) for name in argnameset]
+83 assert sum(val is not None for val in vals) == 1
+84 return func(*args, **kwargs)
+85 return _wrapper
+86 return _decorator
+87else: # pragma: not testing
+88 # We aren't using real PyContracts, so just define our decorators as
+89 # stunt-double no-ops.
+90 contract = dummy_decorator_with_args
+91 one_of = dummy_decorator_with_args
+ +93 def new_contract(*args_unused, **kwargs_unused):
+94 """Dummy no-op implementation of `new_contract`."""
+95 pass
+ + +98def nice_pair(pair):
+99 """Make a nice string representation of a pair of numbers.
+ +101 If the numbers are equal, just return the number, otherwise return the pair
+102 with a dash between them, indicating the range.
+ +104 """
+105 start, end = pair
+106 if start == end:
+107 return "%d" % start
+108 else:
+109 return "%d-%d" % (start, end)
+ + +112def expensive(fn):
+113 """A decorator to indicate that a method shouldn't be called more than once.
+ +115 Normally, this does nothing. During testing, this raises an exception if
+116 called more than once.
+ +118 """
+119 if env.TESTING:
+120 attr = "_once_" + fn.__name__
+ +122 def _wrapper(self):
+123 if hasattr(self, attr):
+124 raise AssertionError("Shouldn't have called %s more than once" % fn.__name__)
+125 setattr(self, attr, True)
+126 return fn(self)
+127 return _wrapper
+128 else:
+129 return fn # pragma: not testing
+ + +132def bool_or_none(b):
+133 """Return bool(b), but preserve None."""
+134 if b is None:
+135 return None
+136 else:
+137 return bool(b)
+ + +140def join_regex(regexes):
+141 """Combine a list of regexes into one that matches any of them."""
+142 return "|".join("(?:%s)" % r for r in regexes)
+ + +145def file_be_gone(path):
+146 """Remove a file, and don't get annoyed if it doesn't exist."""
+147 try:
+148 os.remove(path)
+149 except OSError as e:
+150 if e.errno != errno.ENOENT:
+151 raise
+ + +154def ensure_dir(directory):
+155 """Make sure the directory exists.
+ +157 If `directory` is None or empty, do nothing.
+158 """
+159 if directory and not os.path.isdir(directory):
+160 os.makedirs(directory)
+ + +163def ensure_dir_for_file(path):
+164 """Make sure the directory for the path exists."""
+165 ensure_dir(os.path.dirname(path))
+ + +168def output_encoding(outfile=None):
+169 """Determine the encoding to use for output written to `outfile` or stdout."""
+170 if outfile is None: 170 ↛ 172line 170 didn't jump to line 172
+171 outfile = sys.stdout
+172 encoding = (
+173 getattr(outfile, "encoding", None) or
+174 getattr(sys.__stdout__, "encoding", None) or
+175 locale.getpreferredencoding()
+176 )
+177 return encoding
+ + +180def filename_suffix(suffix):
+181 """Compute a filename suffix for a data file.
+ +183 If `suffix` is a string or None, simply return it. If `suffix` is True,
+184 then build a suffix incorporating the hostname, process id, and a random
+185 number.
+ +187 Returns a string or None.
+ +189 """
+190 if suffix is True:
+191 # If data_suffix was a simple true value, then make a suffix with
+192 # plenty of distinguishing information. We do this here in
+193 # `save()` at the last minute so that the pid will be correct even
+194 # if the process forks.
+195 dice = random.Random(os.urandom(8)).randint(0, 999999)
+196 suffix = "%s.%s.%06d" % (socket.gethostname(), os.getpid(), dice)
+197 return suffix
+ + +200class Hasher(object):
+201 """Hashes Python data into md5."""
+202 def __init__(self):
+203 self.md5 = hashlib.md5()
+ +205 def update(self, v):
+206 """Add `v` to the hash, recursively if needed."""
+207 self.md5.update(to_bytes(str(type(v))))
+208 if isinstance(v, unicode_class):
+209 self.md5.update(v.encode('utf8'))
+210 elif isinstance(v, bytes):
+211 self.md5.update(v)
+212 elif v is None:
+213 pass
+214 elif isinstance(v, (int, float)):
+215 self.md5.update(to_bytes(str(v)))
+216 elif isinstance(v, (tuple, list)):
+217 for e in v:
+218 self.update(e)
+219 elif isinstance(v, dict):
+220 keys = v.keys()
+221 for k in sorted(keys):
+222 self.update(k)
+223 self.update(v[k])
+224 else:
+225 for k in dir(v):
+226 if k.startswith('__'):
+227 continue
+228 a = getattr(v, k)
+229 if inspect.isroutine(a):
+230 continue
+231 self.update(k)
+232 self.update(a)
+233 self.md5.update(b'.')
+ +235 def hexdigest(self):
+236 """Retrieve the hex digest of the hash."""
+237 return self.md5.hexdigest()
+ + +240def _needs_to_implement(that, func_name):
+241 """Helper to raise NotImplementedError in interface stubs."""
+242 if hasattr(that, "_coverage_plugin_name"): 242 ↛ 246line 242 didn't jump to line 246, because the condition on line 242 was never false
+243 thing = "Plugin"
+244 name = that._coverage_plugin_name
+245 else:
+246 thing = "Class"
+247 klass = that.__class__
+248 name = "{klass.__module__}.{klass.__name__}".format(klass=klass)
+ +250 raise NotImplementedError(
+251 "{thing} {name!r} needs to implement {func_name}()".format(
+252 thing=thing, name=name, func_name=func_name
+253 )
+254 )
+ + +257class DefaultValue(object):
+258 """A sentinel object to use for unusual default-value needs.
+ +260 Construct with a string that will be used as the repr, for display in help
+261 and Sphinx output.
+ +263 """
+264 def __init__(self, display_as):
+265 self.display_as = display_as
+ +267 def __repr__(self):
+268 return self.display_as
+ + +271def substitute_variables(text, variables):
+272 """Substitute ``${VAR}`` variables in `text` with their values.
+ +274 Variables in the text can take a number of shell-inspired forms::
+ +276 $VAR
+277 ${VAR}
+278 ${VAR?} strict: an error if VAR isn't defined.
+279 ${VAR-missing} defaulted: "missing" if VAR isn't defined.
+280 $$ just a dollar sign.
+ +282 `variables` is a dictionary of variable values.
+ +284 Returns the resulting text with values substituted.
+ +286 """
+287 dollar_pattern = r"""(?x) # Use extended regex syntax
+288 \$ # A dollar sign,
+289 (?: # then
+290 (?P<dollar>\$) | # a dollar sign, or
+291 (?P<word1>\w+) | # a plain word, or
+292 { # a {-wrapped
+293 (?P<word2>\w+) # word,
+294 (?:
+295 (?P<strict>\?) | # with a strict marker
+296 -(?P<defval>[^}]*) # or a default value
+297 )? # maybe.
+298 }
+299 )
+300 """
+ +302 def dollar_replace(match):
+303 """Called for each $replacement."""
+304 # Only one of the groups will have matched, just get its text.
+305 word = next(g for g in match.group('dollar', 'word1', 'word2') if g) 305 ↛ exitline 305 didn't finish the generator expression on line 305
+306 if word == "$":
+307 return "$"
+308 elif word in variables:
+309 return variables[word]
+310 elif match.group('strict'):
+311 msg = "Variable {} is undefined: {!r}".format(word, text)
+312 raise CoverageException(msg)
+313 else:
+314 return match.group('defval')
+ +316 text = re.sub(dollar_pattern, dollar_replace, text)
+317 return text
+ + +320class BaseCoverageException(Exception):
+321 """The base of all Coverage exceptions."""
+322 pass
+ + +325class CoverageException(BaseCoverageException):
+326 """An exception raised by a coverage.py function."""
+327 pass
+ + +330class NoSource(CoverageException):
+331 """We couldn't find the source for a module."""
+332 pass
+ + +335class NoCode(NoSource):
+336 """We couldn't find any code at all."""
+337 pass
+ + +340class NotPython(CoverageException):
+341 """A source file turned out not to be parsable Python."""
+342 pass
+ + +345class ExceptionDuringRun(CoverageException):
+346 """An exception happened while running customer code.
+ +348 Construct it with three arguments, the values from `sys.exc_info`.
+ +350 """
+351 pass
+ + +354class StopEverything(BaseCoverageException):
+355 """An exception that means everything should stop.
+ +357 The CoverageTest class converts these to SkipTest, so that when running
+358 tests, raising this exception will automatically skip the test.
+ +360 """
+361 pass
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Monkey-patching to add multiprocessing support for coverage.py"""
+ +6import multiprocessing
+7import multiprocessing.process
+8import os
+9import os.path
+10import sys
+11import traceback
+ +13from coverage import env
+14from coverage.misc import contract
+ +16# An attribute that will be set on the module to indicate that it has been
+17# monkey-patched.
+18PATCHED_MARKER = "_coverage$patched"
+ + +21if env.PYVERSION >= (3, 4):
+22 OriginalProcess = multiprocessing.process.BaseProcess
+23else:
+24 OriginalProcess = multiprocessing.Process
+ +26original_bootstrap = OriginalProcess._bootstrap
+ +28class ProcessWithCoverage(OriginalProcess): # pylint: disable=abstract-method
+29 """A replacement for multiprocess.Process that starts coverage."""
+ +31 def _bootstrap(self, *args, **kwargs):
+32 """Wrapper around _bootstrap to start coverage."""
+33 try:
+34 from coverage import Coverage # avoid circular import
+35 cov = Coverage(data_suffix=True)
+36 cov._warn_preimported_source = False
+37 cov.start()
+38 debug = cov._debug
+39 if debug.should("multiproc"): 39 ↛ 40line 39 didn't jump to line 40, because the condition on line 39 was never true
+40 debug.write("Calling multiprocessing bootstrap")
+41 except Exception:
+42 print("Exception during multiprocessing bootstrap init:")
+43 traceback.print_exc(file=sys.stdout)
+44 sys.stdout.flush()
+45 raise
+46 try:
+47 return original_bootstrap(self, *args, **kwargs)
+48 finally:
+49 if debug.should("multiproc"): 49 ↛ 50line 49 didn't jump to line 50, because the condition on line 49 was never true
+50 debug.write("Finished multiprocessing bootstrap")
+51 cov.stop()
+52 cov.save()
+53 if debug.should("multiproc"): 53 ↛ 54line 53 didn't jump to line 54, because the condition on line 53 was never true
+54 debug.write("Saved multiprocessing data")
+ +56class Stowaway(object):
+57 """An object to pickle, so when it is unpickled, it can apply the monkey-patch."""
+58 def __init__(self, rcfile):
+59 self.rcfile = rcfile
+ +61 def __getstate__(self):
+62 return {'rcfile': self.rcfile}
+ +64 def __setstate__(self, state):
+65 patch_multiprocessing(state['rcfile'])
+ + +68@contract(rcfile=str)
+69def patch_multiprocessing(rcfile):
+70 """Monkey-patch the multiprocessing module.
+ +72 This enables coverage measurement of processes started by multiprocessing.
+73 This involves aggressive monkey-patching.
+ +75 `rcfile` is the path to the rcfile being used.
+ +77 """
+ +79 if hasattr(multiprocessing, PATCHED_MARKER):
+80 return
+ +82 if env.PYVERSION >= (3, 4):
+83 OriginalProcess._bootstrap = ProcessWithCoverage._bootstrap
+84 else:
+85 multiprocessing.Process = ProcessWithCoverage
+ +87 # Set the value in ProcessWithCoverage that will be pickled into the child
+88 # process.
+89 os.environ["COVERAGE_RCFILE"] = os.path.abspath(rcfile)
+ +91 # When spawning processes rather than forking them, we have no state in the
+92 # new process. We sneak in there with a Stowaway: we stuff one of our own
+93 # objects into the data that gets pickled and sent to the sub-process. When
+94 # the Stowaway is unpickled, it's __setstate__ method is called, which
+95 # re-applies the monkey-patch.
+96 # Windows only spawns, so this is needed to keep Windows working.
+97 try:
+98 from multiprocessing import spawn
+99 original_get_preparation_data = spawn.get_preparation_data
+100 except (ImportError, AttributeError):
+101 pass
+102 else:
+103 def get_preparation_data_with_stowaway(name):
+104 """Get the original preparation data, and also insert our stowaway."""
+105 d = original_get_preparation_data(name)
+106 d['stowaway'] = Stowaway(rcfile)
+107 return d
+ +109 spawn.get_preparation_data = get_preparation_data_with_stowaway
+ +111 setattr(multiprocessing, PATCHED_MARKER, True)
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""
+5Functions to manipulate packed binary representations of number sets.
+ +7To save space, coverage stores sets of line numbers in SQLite using a packed
+8binary representation called a numbits. A numbits is a set of positive
+9integers.
+ +11A numbits is stored as a blob in the database. The exact meaning of the bytes
+12in the blobs should be considered an implementation detail that might change in
+13the future. Use these functions to work with those binary blobs of data.
+ +15"""
+16import json
+ +18from coverage import env
+19from coverage.backward import byte_to_int, bytes_to_ints, binary_bytes, zip_longest
+20from coverage.misc import contract, new_contract
+ +22if env.PY3:
+23 def _to_blob(b):
+24 """Convert a bytestring into a type SQLite will accept for a blob."""
+25 return b
+ +27 new_contract('blob', lambda v: isinstance(v, bytes))
+28else:
+29 def _to_blob(b):
+30 """Convert a bytestring into a type SQLite will accept for a blob."""
+31 return buffer(b) # pylint: disable=undefined-variable
+ +33 new_contract('blob', lambda v: isinstance(v, buffer)) # pylint: disable=undefined-variable
+ + +36@contract(nums='Iterable', returns='blob')
+37def nums_to_numbits(nums):
+38 """Convert `nums` into a numbits.
+ +40 Arguments:
+41 nums: a reusable iterable of integers, the line numbers to store.
+ +43 Returns:
+44 A binary blob.
+45 """
+46 try:
+47 nbytes = max(nums) // 8 + 1
+48 except ValueError:
+49 # nums was empty.
+50 return _to_blob(b'')
+51 b = bytearray(nbytes)
+52 for num in nums:
+53 b[num//8] |= 1 << num % 8
+54 return _to_blob(bytes(b))
+ + +57@contract(numbits='blob', returns='list[int]')
+58def numbits_to_nums(numbits):
+59 """Convert a numbits into a list of numbers.
+ +61 Arguments:
+62 numbits: a binary blob, the packed number set.
+ +64 Returns:
+65 A list of ints.
+ +67 When registered as a SQLite function by :func:`register_sqlite_functions`,
+68 this returns a string, a JSON-encoded list of ints.
+ +70 """
+71 nums = []
+72 for byte_i, byte in enumerate(bytes_to_ints(numbits)):
+73 for bit_i in range(8):
+74 if (byte & (1 << bit_i)):
+75 nums.append(byte_i * 8 + bit_i)
+76 return nums
+ + +79@contract(numbits1='blob', numbits2='blob', returns='blob')
+80def numbits_union(numbits1, numbits2):
+81 """Compute the union of two numbits.
+ +83 Returns:
+84 A new numbits, the union of `numbits1` and `numbits2`.
+85 """
+86 byte_pairs = zip_longest(bytes_to_ints(numbits1), bytes_to_ints(numbits2), fillvalue=0)
+87 return _to_blob(binary_bytes(b1 | b2 for b1, b2 in byte_pairs))
+ + +90@contract(numbits1='blob', numbits2='blob', returns='blob')
+91def numbits_intersection(numbits1, numbits2):
+92 """Compute the intersection of two numbits.
+ +94 Returns:
+95 A new numbits, the intersection `numbits1` and `numbits2`.
+96 """
+97 byte_pairs = zip_longest(bytes_to_ints(numbits1), bytes_to_ints(numbits2), fillvalue=0)
+98 intersection_bytes = binary_bytes(b1 & b2 for b1, b2 in byte_pairs)
+99 return _to_blob(intersection_bytes.rstrip(b'\0'))
+ + +102@contract(numbits1='blob', numbits2='blob', returns='bool')
+103def numbits_any_intersection(numbits1, numbits2):
+104 """Is there any number that appears in both numbits?
+ +106 Determine whether two number sets have a non-empty intersection. This is
+107 faster than computing the intersection.
+ +109 Returns:
+110 A bool, True if there is any number in both `numbits1` and `numbits2`.
+111 """
+112 byte_pairs = zip_longest(bytes_to_ints(numbits1), bytes_to_ints(numbits2), fillvalue=0)
+113 return any(b1 & b2 for b1, b2 in byte_pairs)
+ + +116@contract(num='int', numbits='blob', returns='bool')
+117def num_in_numbits(num, numbits):
+118 """Does the integer `num` appear in `numbits`?
+ +120 Returns:
+121 A bool, True if `num` is a member of `numbits`.
+122 """
+123 nbyte, nbit = divmod(num, 8)
+124 if nbyte >= len(numbits):
+125 return False
+126 return bool(byte_to_int(numbits[nbyte]) & (1 << nbit))
+ + +129def register_sqlite_functions(connection):
+130 """
+131 Define numbits functions in a SQLite connection.
+ +133 This defines these functions for use in SQLite statements:
+ +135 * :func:`numbits_union`
+136 * :func:`numbits_intersection`
+137 * :func:`numbits_any_intersection`
+138 * :func:`num_in_numbits`
+139 * :func:`numbits_to_nums`
+ +141 `connection` is a :class:`sqlite3.Connection <python:sqlite3.Connection>`
+142 object. After creating the connection, pass it to this function to
+143 register the numbits functions. Then you can use numbits functions in your
+144 queries::
+ +146 import sqlite3
+147 from coverage.numbits import register_sqlite_functions
+ +149 conn = sqlite3.connect('example.db')
+150 register_sqlite_functions(conn)
+151 c = conn.cursor()
+152 # Kind of a nonsense query: find all the files and contexts that
+153 # executed line 47 in any file:
+154 c.execute(
+155 "select file_id, context_id from line_bits where num_in_numbits(?, numbits)",
+156 (47,)
+157 )
+158 """
+159 connection.create_function("numbits_union", 2, numbits_union)
+160 connection.create_function("numbits_intersection", 2, numbits_intersection)
+161 connection.create_function("numbits_any_intersection", 2, numbits_any_intersection)
+162 connection.create_function("num_in_numbits", 2, num_in_numbits)
+163 connection.create_function("numbits_to_nums", 1, lambda b: json.dumps(numbits_to_nums(b)))
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Code parsing for coverage.py."""
+ +6import ast
+7import collections
+8import os
+9import re
+10import token
+11import tokenize
+ +13from coverage import env
+14from coverage.backward import range # pylint: disable=redefined-builtin
+15from coverage.backward import bytes_to_ints, string_class
+16from coverage.bytecode import code_objects
+17from coverage.debug import short_stack
+18from coverage.misc import contract, join_regex, new_contract, nice_pair, one_of
+19from coverage.misc import NoSource, NotPython, StopEverything
+20from coverage.phystokens import compile_unicode, generate_tokens, neuter_encoding_declaration
+ + +23class PythonParser(object):
+24 """Parse code to find executable lines, excluded lines, etc.
+ +26 This information is all based on static analysis: no code execution is
+27 involved.
+ +29 """
+30 @contract(text='unicode|None')
+31 def __init__(self, text=None, filename=None, exclude=None):
+32 """
+33 Source can be provided as `text`, the text itself, or `filename`, from
+34 which the text will be read. Excluded lines are those that match
+35 `exclude`, a regex.
+ +37 """
+38 assert text or filename, "PythonParser needs either text or filename"
+39 self.filename = filename or "<code>"
+40 self.text = text
+41 if not self.text:
+42 from coverage.python import get_python_source
+43 try:
+44 self.text = get_python_source(self.filename)
+45 except IOError as err:
+46 raise NoSource(
+47 "No source for code: '%s': %s" % (self.filename, err)
+48 )
+ +50 self.exclude = exclude
+ +52 # The text lines of the parsed code.
+53 self.lines = self.text.split('\n')
+ +55 # The normalized line numbers of the statements in the code. Exclusions
+56 # are taken into account, and statements are adjusted to their first
+57 # lines.
+58 self.statements = set()
+ +60 # The normalized line numbers of the excluded lines in the code,
+61 # adjusted to their first lines.
+62 self.excluded = set()
+ +64 # The raw_* attributes are only used in this class, and in
+65 # lab/parser.py to show how this class is working.
+ +67 # The line numbers that start statements, as reported by the line
+68 # number table in the bytecode.
+69 self.raw_statements = set()
+ +71 # The raw line numbers of excluded lines of code, as marked by pragmas.
+72 self.raw_excluded = set()
+ +74 # The line numbers of class and function definitions.
+75 self.raw_classdefs = set()
+ +77 # The line numbers of docstring lines.
+78 self.raw_docstrings = set()
+ +80 # Internal detail, used by lab/parser.py.
+81 self.show_tokens = False
+ +83 # A dict mapping line numbers to lexical statement starts for
+84 # multi-line statements.
+85 self._multiline = {}
+ +87 # Lazily-created ByteParser, arc data, and missing arc descriptions.
+88 self._byte_parser = None
+89 self._all_arcs = None
+90 self._missing_arc_fragments = None
+ +92 @property
+93 def byte_parser(self):
+94 """Create a ByteParser on demand."""
+95 if not self._byte_parser: 95 ↛ 97line 95 didn't jump to line 97, because the condition on line 95 was never false
+96 self._byte_parser = ByteParser(self.text, filename=self.filename)
+97 return self._byte_parser
+ +99 def lines_matching(self, *regexes):
+100 """Find the lines matching one of a list of regexes.
+ +102 Returns a set of line numbers, the lines that contain a match for one
+103 of the regexes in `regexes`. The entire line needn't match, just a
+104 part of it.
+ +106 """
+107 combined = join_regex(regexes)
+108 if env.PY2:
+109 combined = combined.decode("utf8")
+110 regex_c = re.compile(combined)
+111 matches = set()
+112 for i, ltext in enumerate(self.lines, start=1):
+113 if regex_c.search(ltext):
+114 matches.add(i)
+115 return matches
+ +117 def _raw_parse(self):
+118 """Parse the source to find the interesting facts about its lines.
+ +120 A handful of attributes are updated.
+ +122 """
+123 # Find lines which match an exclusion pattern.
+124 if self.exclude:
+125 self.raw_excluded = self.lines_matching(self.exclude)
+ +127 # Tokenize, to find excluded suites, to find docstrings, and to find
+128 # multi-line statements.
+129 indent = 0
+130 exclude_indent = 0
+131 excluding = False
+132 excluding_decorators = False
+133 prev_toktype = token.INDENT
+134 first_line = None
+135 empty = True
+136 first_on_line = True
+ +138 tokgen = generate_tokens(self.text)
+139 for toktype, ttext, (slineno, _), (elineno, _), ltext in tokgen:
+140 if self.show_tokens: # pragma: debugging
+141 print("%10s %5s %-20r %r" % (
+142 tokenize.tok_name.get(toktype, toktype),
+143 nice_pair((slineno, elineno)), ttext, ltext
+144 ))
+145 if toktype == token.INDENT:
+146 indent += 1
+147 elif toktype == token.DEDENT:
+148 indent -= 1
+149 elif toktype == token.NAME:
+150 if ttext == 'class':
+151 # Class definitions look like branches in the bytecode, so
+152 # we need to exclude them. The simplest way is to note the
+153 # lines with the 'class' keyword.
+154 self.raw_classdefs.add(slineno)
+155 elif toktype == token.OP:
+156 if ttext == ':':
+157 should_exclude = (elineno in self.raw_excluded) or excluding_decorators
+158 if not excluding and should_exclude:
+159 # Start excluding a suite. We trigger off of the colon
+160 # token so that the #pragma comment will be recognized on
+161 # the same line as the colon.
+162 self.raw_excluded.add(elineno)
+163 exclude_indent = indent
+164 excluding = True
+165 excluding_decorators = False
+166 elif ttext == '@' and first_on_line:
+167 # A decorator.
+168 if elineno in self.raw_excluded:
+169 excluding_decorators = True
+170 if excluding_decorators:
+171 self.raw_excluded.add(elineno)
+172 elif toktype == token.STRING and prev_toktype == token.INDENT:
+173 # Strings that are first on an indented line are docstrings.
+174 # (a trick from trace.py in the stdlib.) This works for
+175 # 99.9999% of cases. For the rest (!) see:
+176 # http://stackoverflow.com/questions/1769332/x/1769794#1769794
+177 self.raw_docstrings.update(range(slineno, elineno+1))
+178 elif toktype == token.NEWLINE:
+179 if first_line is not None and elineno != first_line:
+180 # We're at the end of a line, and we've ended on a
+181 # different line than the first line of the statement,
+182 # so record a multi-line range.
+183 for l in range(first_line, elineno+1):
+184 self._multiline[l] = first_line
+185 first_line = None
+186 first_on_line = True
+ +188 if ttext.strip() and toktype != tokenize.COMMENT:
+189 # A non-whitespace token.
+190 empty = False
+191 if first_line is None:
+192 # The token is not whitespace, and is the first in a
+193 # statement.
+194 first_line = slineno
+195 # Check whether to end an excluded suite.
+196 if excluding and indent <= exclude_indent:
+197 excluding = False
+198 if excluding:
+199 self.raw_excluded.add(elineno)
+200 first_on_line = False
+ +202 prev_toktype = toktype
+ +204 # Find the starts of the executable statements.
+205 if not empty:
+206 self.raw_statements.update(self.byte_parser._find_statements())
+ +208 # The first line of modules can lie and say 1 always, even if the first
+209 # line of code is later. If so, map 1 to the actual first line of the
+210 # module.
+211 if env.PYBEHAVIOR.module_firstline_1 and self._multiline:
+212 self._multiline[1] = min(self.raw_statements)
+ +214 def first_line(self, line):
+215 """Return the first line number of the statement including `line`."""
+216 if line < 0:
+217 line = -self._multiline.get(-line, -line)
+218 else:
+219 line = self._multiline.get(line, line)
+220 return line
+ +222 def first_lines(self, lines):
+223 """Map the line numbers in `lines` to the correct first line of the
+224 statement.
+ +226 Returns a set of the first lines.
+ +228 """
+229 return {self.first_line(l) for l in lines}
+ +231 def translate_lines(self, lines):
+232 """Implement `FileReporter.translate_lines`."""
+233 return self.first_lines(lines)
+ +235 def translate_arcs(self, arcs):
+236 """Implement `FileReporter.translate_arcs`."""
+237 return [(self.first_line(a), self.first_line(b)) for (a, b) in arcs]
+ +239 def parse_source(self):
+240 """Parse source text to find executable lines, excluded lines, etc.
+ +242 Sets the .excluded and .statements attributes, normalized to the first
+243 line of multi-line statements.
+ +245 """
+246 try:
+247 self._raw_parse()
+248 except (tokenize.TokenError, IndentationError) as err:
+249 if hasattr(err, "lineno"):
+250 lineno = err.lineno # IndentationError
+251 else:
+252 lineno = err.args[1][0] # TokenError
+253 raise NotPython(
+254 u"Couldn't parse '%s' as Python source: '%s' at line %d" % (
+255 self.filename, err.args[0], lineno
+256 )
+257 )
+ +259 self.excluded = self.first_lines(self.raw_excluded)
+ +261 ignore = self.excluded | self.raw_docstrings
+262 starts = self.raw_statements - ignore
+263 self.statements = self.first_lines(starts) - ignore
+ +265 def arcs(self):
+266 """Get information about the arcs available in the code.
+ +268 Returns a set of line number pairs. Line numbers have been normalized
+269 to the first line of multi-line statements.
+ +271 """
+272 if self._all_arcs is None:
+273 self._analyze_ast()
+274 return self._all_arcs
+ +276 def _analyze_ast(self):
+277 """Run the AstArcAnalyzer and save its results.
+ +279 `_all_arcs` is the set of arcs in the code.
+ +281 """
+282 aaa = AstArcAnalyzer(self.text, self.raw_statements, self._multiline)
+283 aaa.analyze()
+ +285 self._all_arcs = set()
+286 for l1, l2 in aaa.arcs:
+287 fl1 = self.first_line(l1)
+288 fl2 = self.first_line(l2)
+289 if fl1 != fl2:
+290 self._all_arcs.add((fl1, fl2))
+ +292 self._missing_arc_fragments = aaa.missing_arc_fragments
+ +294 def exit_counts(self):
+295 """Get a count of exits from that each line.
+ +297 Excluded lines are excluded.
+ +299 """
+300 exit_counts = collections.defaultdict(int)
+301 for l1, l2 in self.arcs():
+302 if l1 < 0:
+303 # Don't ever report -1 as a line number
+304 continue
+305 if l1 in self.excluded:
+306 # Don't report excluded lines as line numbers.
+307 continue
+308 if l2 in self.excluded:
+309 # Arcs to excluded lines shouldn't count.
+310 continue
+311 exit_counts[l1] += 1
+ +313 # Class definitions have one extra exit, so remove one for each:
+314 for l in self.raw_classdefs:
+315 # Ensure key is there: class definitions can include excluded lines.
+316 if l in exit_counts:
+317 exit_counts[l] -= 1
+ +319 return exit_counts
+ +321 def missing_arc_description(self, start, end, executed_arcs=None):
+322 """Provide an English sentence describing a missing arc."""
+323 if self._missing_arc_fragments is None:
+324 self._analyze_ast()
+ +326 actual_start = start
+ +328 if (
+329 executed_arcs and
+330 end < 0 and end == -start and
+331 (end, start) not in executed_arcs and
+332 (end, start) in self._missing_arc_fragments
+333 ):
+334 # It's a one-line callable, and we never even started it,
+335 # and we have a message about not starting it.
+336 start, end = end, start
+ +338 fragment_pairs = self._missing_arc_fragments.get((start, end), [(None, None)])
+ +340 msgs = []
+341 for smsg, emsg in fragment_pairs:
+342 if emsg is None:
+343 if end < 0:
+344 # Hmm, maybe we have a one-line callable, let's check.
+345 if (-end, end) in self._missing_arc_fragments: 345 ↛ 347line 345 didn't jump to line 347, because the condition on line 345 was never false
+346 return self.missing_arc_description(-end, end)
+347 emsg = "didn't jump to the function exit"
+348 else:
+349 emsg = "didn't jump to line {lineno}"
+350 emsg = emsg.format(lineno=end)
+ +352 msg = "line {start} {emsg}".format(start=actual_start, emsg=emsg)
+353 if smsg is not None:
+354 msg += ", because {smsg}".format(smsg=smsg.format(lineno=actual_start))
+ +356 msgs.append(msg)
+ +358 return " or ".join(msgs)
+ + +361class ByteParser(object):
+362 """Parse bytecode to understand the structure of code."""
+ +364 @contract(text='unicode')
+365 def __init__(self, text, code=None, filename=None):
+366 self.text = text
+367 if code:
+368 self.code = code
+369 else:
+370 try:
+371 self.code = compile_unicode(text, filename, "exec")
+372 except SyntaxError as synerr:
+373 raise NotPython(
+374 u"Couldn't parse '%s' as Python source: '%s' at line %d" % (
+375 filename, synerr.msg, synerr.lineno
+376 )
+377 )
+ +379 # Alternative Python implementations don't always provide all the
+380 # attributes on code objects that we need to do the analysis.
+381 for attr in ['co_lnotab', 'co_firstlineno']:
+382 if not hasattr(self.code, attr):
+383 raise StopEverything( # pragma: only jython
+384 "This implementation of Python doesn't support code analysis.\n"
+385 "Run coverage.py under another Python for this command."
+386 )
+ +388 def child_parsers(self):
+389 """Iterate over all the code objects nested within this one.
+ +391 The iteration includes `self` as its first value.
+ +393 """
+394 return (ByteParser(self.text, code=c) for c in code_objects(self.code))
+ +396 def _line_numbers(self):
+397 """Yield the line numbers possible in this code object.
+ +399 Uses co_lnotab described in Python/compile.c to find the
+400 line numbers. Produces a sequence: l0, l1, ...
+401 """
+402 if hasattr(self.code, "co_lines"):
+403 for _, _, line in self.code.co_lines():
+404 if line is not None:
+405 yield line
+406 else:
+407 # Adapted from dis.py in the standard library.
+408 byte_increments = bytes_to_ints(self.code.co_lnotab[0::2])
+409 line_increments = bytes_to_ints(self.code.co_lnotab[1::2])
+ +411 last_line_num = None
+412 line_num = self.code.co_firstlineno
+413 byte_num = 0
+414 for byte_incr, line_incr in zip(byte_increments, line_increments):
+415 if byte_incr:
+416 if line_num != last_line_num:
+417 yield line_num
+418 last_line_num = line_num
+419 byte_num += byte_incr
+420 if env.PYBEHAVIOR.negative_lnotab and line_incr >= 0x80:
+421 line_incr -= 0x100
+422 line_num += line_incr
+423 if line_num != last_line_num:
+424 yield line_num
+ +426 def _find_statements(self):
+427 """Find the statements in `self.code`.
+ +429 Produce a sequence of line numbers that start statements. Recurses
+430 into all code objects reachable from `self.code`.
+ +432 """
+433 for bp in self.child_parsers():
+434 # Get all of the lineno information from this code.
+435 for l in bp._line_numbers():
+436 yield l
+ + +439#
+440# AST analysis
+441#
+ +443class LoopBlock(object):
+444 """A block on the block stack representing a `for` or `while` loop."""
+445 @contract(start=int)
+446 def __init__(self, start):
+447 # The line number where the loop starts.
+448 self.start = start
+449 # A set of ArcStarts, the arcs from break statements exiting this loop.
+450 self.break_exits = set()
+ + +453class FunctionBlock(object):
+454 """A block on the block stack representing a function definition."""
+455 @contract(start=int, name=str)
+456 def __init__(self, start, name):
+457 # The line number where the function starts.
+458 self.start = start
+459 # The name of the function.
+460 self.name = name
+ + +463class TryBlock(object):
+464 """A block on the block stack representing a `try` block."""
+465 @contract(handler_start='int|None', final_start='int|None')
+466 def __init__(self, handler_start, final_start):
+467 # The line number of the first "except" handler, if any.
+468 self.handler_start = handler_start
+469 # The line number of the "finally:" clause, if any.
+470 self.final_start = final_start
+ +472 # The ArcStarts for breaks/continues/returns/raises inside the "try:"
+473 # that need to route through the "finally:" clause.
+474 self.break_from = set()
+475 self.continue_from = set()
+476 self.return_from = set()
+477 self.raise_from = set()
+ + +480class ArcStart(collections.namedtuple("Arc", "lineno, cause")):
+481 """The information needed to start an arc.
+ +483 `lineno` is the line number the arc starts from.
+ +485 `cause` is an English text fragment used as the `startmsg` for
+486 AstArcAnalyzer.missing_arc_fragments. It will be used to describe why an
+487 arc wasn't executed, so should fit well into a sentence of the form,
+488 "Line 17 didn't run because {cause}." The fragment can include "{lineno}"
+489 to have `lineno` interpolated into it.
+ +491 """
+492 def __new__(cls, lineno, cause=None):
+493 return super(ArcStart, cls).__new__(cls, lineno, cause)
+ + +496# Define contract words that PyContract doesn't have.
+497# ArcStarts is for a list or set of ArcStart's.
+498new_contract('ArcStarts', lambda seq: all(isinstance(x, ArcStart) for x in seq))
+ + +501# Turn on AST dumps with an environment variable.
+502# $set_env.py: COVERAGE_AST_DUMP - Dump the AST nodes when parsing code.
+503AST_DUMP = bool(int(os.environ.get("COVERAGE_AST_DUMP", 0)))
+ +505class NodeList(object):
+506 """A synthetic fictitious node, containing a sequence of nodes.
+ +508 This is used when collapsing optimized if-statements, to represent the
+509 unconditional execution of one of the clauses.
+ +511 """
+512 def __init__(self, body):
+513 self.body = body
+514 self.lineno = body[0].lineno
+ + +517# TODO: some add_arcs methods here don't add arcs, they return them. Rename them.
+518# TODO: the cause messages have too many commas.
+519# TODO: Shouldn't the cause messages join with "and" instead of "or"?
+ +521class AstArcAnalyzer(object):
+522 """Analyze source text with an AST to find executable code paths."""
+ +524 @contract(text='unicode', statements=set)
+525 def __init__(self, text, statements, multiline):
+526 self.root_node = ast.parse(neuter_encoding_declaration(text))
+527 # TODO: I think this is happening in too many places.
+528 self.statements = {multiline.get(l, l) for l in statements}
+529 self.multiline = multiline
+ +531 if AST_DUMP: # pragma: debugging
+532 # Dump the AST so that failing tests have helpful output.
+533 print("Statements: {}".format(self.statements))
+534 print("Multiline map: {}".format(self.multiline))
+535 ast_dump(self.root_node)
+ +537 self.arcs = set()
+ +539 # A map from arc pairs to a list of pairs of sentence fragments:
+540 # { (start, end): [(startmsg, endmsg), ...], }
+541 #
+542 # For an arc from line 17, they should be usable like:
+543 # "Line 17 {endmsg}, because {startmsg}"
+544 self.missing_arc_fragments = collections.defaultdict(list)
+545 self.block_stack = []
+ +547 # $set_env.py: COVERAGE_TRACK_ARCS - Trace every arc added while parsing code.
+548 self.debug = bool(int(os.environ.get("COVERAGE_TRACK_ARCS", 0)))
+ +550 def analyze(self):
+551 """Examine the AST tree from `root_node` to determine possible arcs.
+ +553 This sets the `arcs` attribute to be a set of (from, to) line number
+554 pairs.
+ +556 """
+557 for node in ast.walk(self.root_node):
+558 node_name = node.__class__.__name__
+559 code_object_handler = getattr(self, "_code_object__" + node_name, None)
+560 if code_object_handler is not None:
+561 code_object_handler(node)
+ +563 @contract(start=int, end=int)
+564 def add_arc(self, start, end, smsg=None, emsg=None):
+565 """Add an arc, including message fragments to use if it is missing."""
+566 if self.debug: # pragma: debugging
+567 print("\nAdding arc: ({}, {}): {!r}, {!r}".format(start, end, smsg, emsg))
+568 print(short_stack(limit=6))
+569 self.arcs.add((start, end))
+ +571 if smsg is not None or emsg is not None:
+572 self.missing_arc_fragments[(start, end)].append((smsg, emsg))
+ +574 def nearest_blocks(self):
+575 """Yield the blocks in nearest-to-farthest order."""
+576 return reversed(self.block_stack)
+ +578 @contract(returns=int)
+579 def line_for_node(self, node):
+580 """What is the right line number to use for this node?
+ +582 This dispatches to _line__Node functions where needed.
+ +584 """
+585 node_name = node.__class__.__name__
+586 handler = getattr(self, "_line__" + node_name, None)
+587 if handler is not None:
+588 return handler(node)
+589 else:
+590 return node.lineno
+ +592 def _line_decorated(self, node):
+593 """Compute first line number for things that can be decorated (classes and functions)."""
+594 lineno = node.lineno
+595 if env.PYBEHAVIOR.trace_decorated_def:
+596 if node.decorator_list:
+597 lineno = node.decorator_list[0].lineno
+598 return lineno
+ +600 def _line__Assign(self, node):
+601 return self.line_for_node(node.value)
+ +603 _line__ClassDef = _line_decorated
+ +605 def _line__Dict(self, node):
+606 # Python 3.5 changed how dict literals are made.
+607 if env.PYVERSION >= (3, 5) and node.keys:
+608 if node.keys[0] is not None:
+609 return node.keys[0].lineno
+610 else:
+611 # Unpacked dict literals `{**{'a':1}}` have None as the key,
+612 # use the value in that case.
+613 return node.values[0].lineno
+614 else:
+615 return node.lineno
+ +617 _line__FunctionDef = _line_decorated
+618 _line__AsyncFunctionDef = _line_decorated
+ +620 def _line__List(self, node):
+621 if node.elts:
+622 return self.line_for_node(node.elts[0])
+623 else:
+624 return node.lineno
+ +626 def _line__Module(self, node):
+627 if env.PYBEHAVIOR.module_firstline_1:
+628 return 1
+629 elif node.body:
+630 return self.line_for_node(node.body[0])
+631 else:
+632 # Empty modules have no line number, they always start at 1.
+633 return 1
+ +635 # The node types that just flow to the next node with no complications.
+636 OK_TO_DEFAULT = {
+637 "Assign", "Assert", "AugAssign", "Delete", "Exec", "Expr", "Global",
+638 "Import", "ImportFrom", "Nonlocal", "Pass", "Print",
+639 }
+ +641 @contract(returns='ArcStarts')
+642 def add_arcs(self, node):
+643 """Add the arcs for `node`.
+ +645 Return a set of ArcStarts, exits from this node to the next. Because a
+646 node represents an entire sub-tree (including its children), the exits
+647 from a node can be arbitrarily complex::
+ +649 if something(1):
+650 if other(2):
+651 doit(3)
+652 else:
+653 doit(5)
+ +655 There are two exits from line 1: they start at line 3 and line 5.
+ +657 """
+658 node_name = node.__class__.__name__
+659 handler = getattr(self, "_handle__" + node_name, None)
+660 if handler is not None:
+661 return handler(node)
+662 else:
+663 # No handler: either it's something that's ok to default (a simple
+664 # statement), or it's something we overlooked. Change this 0 to 1
+665 # to see if it's overlooked.
+666 if 0:
+667 if node_name not in self.OK_TO_DEFAULT:
+668 print("*** Unhandled: {}".format(node))
+ +670 # Default for simple statements: one exit from this node.
+671 return {ArcStart(self.line_for_node(node))}
+ +673 @one_of("from_start, prev_starts")
+674 @contract(returns='ArcStarts')
+675 def add_body_arcs(self, body, from_start=None, prev_starts=None):
+676 """Add arcs for the body of a compound statement.
+ +678 `body` is the body node. `from_start` is a single `ArcStart` that can
+679 be the previous line in flow before this body. `prev_starts` is a set
+680 of ArcStarts that can be the previous line. Only one of them should be
+681 given.
+ +683 Returns a set of ArcStarts, the exits from this body.
+ +685 """
+686 if prev_starts is None:
+687 prev_starts = {from_start}
+688 for body_node in body:
+689 lineno = self.line_for_node(body_node)
+690 first_line = self.multiline.get(lineno, lineno)
+691 if first_line not in self.statements:
+692 body_node = self.find_non_missing_node(body_node)
+693 if body_node is None:
+694 continue
+695 lineno = self.line_for_node(body_node)
+696 for prev_start in prev_starts:
+697 self.add_arc(prev_start.lineno, lineno, prev_start.cause)
+698 prev_starts = self.add_arcs(body_node)
+699 return prev_starts
+ +701 def find_non_missing_node(self, node):
+702 """Search `node` looking for a child that has not been optimized away.
+ +704 This might return the node you started with, or it will work recursively
+705 to find a child node in self.statements.
+ +707 Returns a node, or None if none of the node remains.
+ +709 """
+710 # This repeats work just done in add_body_arcs, but this duplication
+711 # means we can avoid a function call in the 99.9999% case of not
+712 # optimizing away statements.
+713 lineno = self.line_for_node(node)
+714 first_line = self.multiline.get(lineno, lineno)
+715 if first_line in self.statements:
+716 return node
+ +718 missing_fn = getattr(self, "_missing__" + node.__class__.__name__, None)
+719 if missing_fn:
+720 node = missing_fn(node)
+721 else:
+722 node = None
+723 return node
+ +725 # Missing nodes: _missing__*
+726 #
+727 # Entire statements can be optimized away by Python. They will appear in
+728 # the AST, but not the bytecode. These functions are called (by
+729 # find_non_missing_node) to find a node to use instead of the missing
+730 # node. They can return None if the node should truly be gone.
+ +732 def _missing__If(self, node):
+733 # If the if-node is missing, then one of its children might still be
+734 # here, but not both. So return the first of the two that isn't missing.
+735 # Use a NodeList to hold the clauses as a single node.
+736 non_missing = self.find_non_missing_node(NodeList(node.body))
+737 if non_missing:
+738 return non_missing
+739 if node.orelse:
+740 return self.find_non_missing_node(NodeList(node.orelse))
+741 return None
+ +743 def _missing__NodeList(self, node):
+744 # A NodeList might be a mixture of missing and present nodes. Find the
+745 # ones that are present.
+746 non_missing_children = []
+747 for child in node.body:
+748 child = self.find_non_missing_node(child)
+749 if child is not None:
+750 non_missing_children.append(child)
+ +752 # Return the simplest representation of the present children.
+753 if not non_missing_children:
+754 return None
+755 if len(non_missing_children) == 1:
+756 return non_missing_children[0]
+757 return NodeList(non_missing_children)
+ +759 def _missing__While(self, node):
+760 body_nodes = self.find_non_missing_node(NodeList(node.body))
+761 if not body_nodes: 761 ↛ 762line 761 didn't jump to line 762, because the condition on line 761 was never true
+762 return None
+763 # Make a synthetic While-true node.
+764 new_while = ast.While()
+765 new_while.lineno = body_nodes.lineno
+766 new_while.test = ast.Name()
+767 new_while.test.lineno = body_nodes.lineno
+768 new_while.test.id = "True"
+769 new_while.body = body_nodes.body
+770 new_while.orelse = None
+771 return new_while
+ +773 def is_constant_expr(self, node):
+774 """Is this a compile-time constant?"""
+775 node_name = node.__class__.__name__
+776 if node_name in ["Constant", "NameConstant", "Num"]:
+777 return "Num"
+778 elif node_name == "Name":
+779 if node.id in ["True", "False", "None", "__debug__"]:
+780 return "Name"
+781 return None
+ +783 # In the fullness of time, these might be good tests to write:
+784 # while EXPR:
+785 # while False:
+786 # listcomps hidden deep in other expressions
+787 # listcomps hidden in lists: x = [[i for i in range(10)]]
+788 # nested function definitions
+ + +791 # Exit processing: process_*_exits
+792 #
+793 # These functions process the four kinds of jump exits: break, continue,
+794 # raise, and return. To figure out where an exit goes, we have to look at
+795 # the block stack context. For example, a break will jump to the nearest
+796 # enclosing loop block, or the nearest enclosing finally block, whichever
+797 # is nearer.
+ +799 @contract(exits='ArcStarts')
+800 def process_break_exits(self, exits):
+801 """Add arcs due to jumps from `exits` being breaks."""
+802 for block in self.nearest_blocks(): 802 ↛ exitline 802 didn't return from function 'process_break_exits', because the loop on line 802 didn't complete
+803 if isinstance(block, LoopBlock):
+804 block.break_exits.update(exits)
+805 break
+806 elif isinstance(block, TryBlock) and block.final_start is not None: 806 ↛ 802line 806 didn't jump to line 802, because the condition on line 806 was never false
+807 block.break_from.update(exits)
+808 break
+ +810 @contract(exits='ArcStarts')
+811 def process_continue_exits(self, exits):
+812 """Add arcs due to jumps from `exits` being continues."""
+813 for block in self.nearest_blocks(): 813 ↛ exitline 813 didn't return from function 'process_continue_exits', because the loop on line 813 didn't complete
+814 if isinstance(block, LoopBlock):
+815 for xit in exits:
+816 self.add_arc(xit.lineno, block.start, xit.cause)
+817 break
+818 elif isinstance(block, TryBlock) and block.final_start is not None: 818 ↛ 813line 818 didn't jump to line 813, because the condition on line 818 was never false
+819 block.continue_from.update(exits)
+820 break
+ +822 @contract(exits='ArcStarts')
+823 def process_raise_exits(self, exits):
+824 """Add arcs due to jumps from `exits` being raises."""
+825 for block in self.nearest_blocks():
+826 if isinstance(block, TryBlock):
+827 if block.handler_start is not None:
+828 for xit in exits:
+829 self.add_arc(xit.lineno, block.handler_start, xit.cause)
+830 break
+831 elif block.final_start is not None: 831 ↛ 825line 831 didn't jump to line 825, because the condition on line 831 was never false
+832 block.raise_from.update(exits)
+833 break
+834 elif isinstance(block, FunctionBlock):
+835 for xit in exits:
+836 self.add_arc(
+837 xit.lineno, -block.start, xit.cause,
+838 "didn't except from function {!r}".format(block.name),
+839 )
+840 break
+ +842 @contract(exits='ArcStarts')
+843 def process_return_exits(self, exits):
+844 """Add arcs due to jumps from `exits` being returns."""
+845 for block in self.nearest_blocks(): 845 ↛ exitline 845 didn't return from function 'process_return_exits', because the loop on line 845 didn't complete
+846 if isinstance(block, TryBlock) and block.final_start is not None:
+847 block.return_from.update(exits)
+848 break
+849 elif isinstance(block, FunctionBlock):
+850 for xit in exits:
+851 self.add_arc(
+852 xit.lineno, -block.start, xit.cause,
+853 "didn't return from function {!r}".format(block.name),
+854 )
+855 break
+ + +858 # Handlers: _handle__*
+859 #
+860 # Each handler deals with a specific AST node type, dispatched from
+861 # add_arcs. Handlers return the set of exits from that node, and can
+862 # also call self.add_arc to record arcs they find. These functions mirror
+863 # the Python semantics of each syntactic construct. See the docstring
+864 # for add_arcs to understand the concept of exits from a node.
+ +866 @contract(returns='ArcStarts')
+867 def _handle__Break(self, node):
+868 here = self.line_for_node(node)
+869 break_start = ArcStart(here, cause="the break on line {lineno} wasn't executed")
+870 self.process_break_exits([break_start])
+871 return set()
+ +873 @contract(returns='ArcStarts')
+874 def _handle_decorated(self, node):
+875 """Add arcs for things that can be decorated (classes and functions)."""
+876 main_line = last = node.lineno
+877 if node.decorator_list:
+878 if env.PYBEHAVIOR.trace_decorated_def:
+879 last = None
+880 for dec_node in node.decorator_list:
+881 dec_start = self.line_for_node(dec_node)
+882 if last is not None and dec_start != last:
+883 self.add_arc(last, dec_start)
+884 last = dec_start
+885 if env.PYBEHAVIOR.trace_decorated_def:
+886 self.add_arc(last, main_line)
+887 last = main_line
+888 # The definition line may have been missed, but we should have it
+889 # in `self.statements`. For some constructs, `line_for_node` is
+890 # not what we'd think of as the first line in the statement, so map
+891 # it to the first one.
+892 if node.body: 892 ↛ 900line 892 didn't jump to line 900, because the condition on line 892 was never false
+893 body_start = self.line_for_node(node.body[0])
+894 body_start = self.multiline.get(body_start, body_start)
+895 for lineno in range(last+1, body_start):
+896 if lineno in self.statements:
+897 self.add_arc(last, lineno)
+898 last = lineno
+899 # The body is handled in collect_arcs.
+900 return {ArcStart(last)}
+ +902 _handle__ClassDef = _handle_decorated
+ +904 @contract(returns='ArcStarts')
+905 def _handle__Continue(self, node):
+906 here = self.line_for_node(node)
+907 continue_start = ArcStart(here, cause="the continue on line {lineno} wasn't executed")
+908 self.process_continue_exits([continue_start])
+909 return set()
+ +911 @contract(returns='ArcStarts')
+912 def _handle__For(self, node):
+913 start = self.line_for_node(node.iter)
+914 self.block_stack.append(LoopBlock(start=start))
+915 from_start = ArcStart(start, cause="the loop on line {lineno} never started")
+916 exits = self.add_body_arcs(node.body, from_start=from_start)
+917 # Any exit from the body will go back to the top of the loop.
+918 for xit in exits:
+919 self.add_arc(xit.lineno, start, xit.cause)
+920 my_block = self.block_stack.pop()
+921 exits = my_block.break_exits
+922 from_start = ArcStart(start, cause="the loop on line {lineno} didn't complete")
+923 if node.orelse:
+924 else_exits = self.add_body_arcs(node.orelse, from_start=from_start)
+925 exits |= else_exits
+926 else:
+927 # No else clause: exit from the for line.
+928 exits.add(from_start)
+929 return exits
+ +931 _handle__AsyncFor = _handle__For
+ +933 _handle__FunctionDef = _handle_decorated
+934 _handle__AsyncFunctionDef = _handle_decorated
+ +936 @contract(returns='ArcStarts')
+937 def _handle__If(self, node):
+938 start = self.line_for_node(node.test)
+939 from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
+940 exits = self.add_body_arcs(node.body, from_start=from_start)
+941 from_start = ArcStart(start, cause="the condition on line {lineno} was never false")
+942 exits |= self.add_body_arcs(node.orelse, from_start=from_start)
+943 return exits
+ +945 @contract(returns='ArcStarts')
+946 def _handle__NodeList(self, node):
+947 start = self.line_for_node(node)
+948 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+949 return exits
+ +951 @contract(returns='ArcStarts')
+952 def _handle__Raise(self, node):
+953 here = self.line_for_node(node)
+954 raise_start = ArcStart(here, cause="the raise on line {lineno} wasn't executed")
+955 self.process_raise_exits([raise_start])
+956 # `raise` statement jumps away, no exits from here.
+957 return set()
+ +959 @contract(returns='ArcStarts')
+960 def _handle__Return(self, node):
+961 here = self.line_for_node(node)
+962 return_start = ArcStart(here, cause="the return on line {lineno} wasn't executed")
+963 self.process_return_exits([return_start])
+964 # `return` statement jumps away, no exits from here.
+965 return set()
+ +967 @contract(returns='ArcStarts')
+968 def _handle__Try(self, node):
+969 if node.handlers:
+970 handler_start = self.line_for_node(node.handlers[0])
+971 else:
+972 handler_start = None
+ +974 if node.finalbody:
+975 final_start = self.line_for_node(node.finalbody[0])
+976 else:
+977 final_start = None
+ +979 try_block = TryBlock(handler_start, final_start)
+980 self.block_stack.append(try_block)
+ +982 start = self.line_for_node(node)
+983 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+ +985 # We're done with the `try` body, so this block no longer handles
+986 # exceptions. We keep the block so the `finally` clause can pick up
+987 # flows from the handlers and `else` clause.
+988 if node.finalbody:
+989 try_block.handler_start = None
+990 if node.handlers:
+991 # If there are `except` clauses, then raises in the try body
+992 # will already jump to them. Start this set over for raises in
+993 # `except` and `else`.
+994 try_block.raise_from = set()
+995 else:
+996 self.block_stack.pop()
+ +998 handler_exits = set()
+ +1000 if node.handlers:
+1001 last_handler_start = None
+1002 for handler_node in node.handlers:
+1003 handler_start = self.line_for_node(handler_node)
+1004 if last_handler_start is not None:
+1005 self.add_arc(last_handler_start, handler_start)
+1006 last_handler_start = handler_start
+1007 from_cause = "the exception caught by line {lineno} didn't happen"
+1008 from_start = ArcStart(handler_start, cause=from_cause)
+1009 handler_exits |= self.add_body_arcs(handler_node.body, from_start=from_start)
+ +1011 if node.orelse:
+1012 exits = self.add_body_arcs(node.orelse, prev_starts=exits)
+ +1014 exits |= handler_exits
+ +1016 if node.finalbody:
+1017 self.block_stack.pop()
+1018 final_from = ( # You can get to the `finally` clause from:
+1019 exits | # the exits of the body or `else` clause,
+1020 try_block.break_from | # or a `break`,
+1021 try_block.continue_from | # or a `continue`,
+1022 try_block.raise_from | # or a `raise`,
+1023 try_block.return_from # or a `return`.
+1024 )
+ +1026 final_exits = self.add_body_arcs(node.finalbody, prev_starts=final_from)
+ +1028 if try_block.break_from:
+1029 if env.PYBEHAVIOR.finally_jumps_back:
+1030 for break_line in try_block.break_from:
+1031 lineno = break_line.lineno
+1032 cause = break_line.cause.format(lineno=lineno)
+1033 for final_exit in final_exits:
+1034 self.add_arc(final_exit.lineno, lineno, cause)
+1035 breaks = try_block.break_from
+1036 else:
+1037 breaks = self._combine_finally_starts(try_block.break_from, final_exits)
+1038 self.process_break_exits(breaks)
+ +1040 if try_block.continue_from:
+1041 if env.PYBEHAVIOR.finally_jumps_back:
+1042 for continue_line in try_block.continue_from:
+1043 lineno = continue_line.lineno
+1044 cause = continue_line.cause.format(lineno=lineno)
+1045 for final_exit in final_exits:
+1046 self.add_arc(final_exit.lineno, lineno, cause)
+1047 continues = try_block.continue_from
+1048 else:
+1049 continues = self._combine_finally_starts(try_block.continue_from, final_exits)
+1050 self.process_continue_exits(continues)
+ +1052 if try_block.raise_from:
+1053 self.process_raise_exits(
+1054 self._combine_finally_starts(try_block.raise_from, final_exits)
+1055 )
+ +1057 if try_block.return_from:
+1058 if env.PYBEHAVIOR.finally_jumps_back:
+1059 for return_line in try_block.return_from:
+1060 lineno = return_line.lineno
+1061 cause = return_line.cause.format(lineno=lineno)
+1062 for final_exit in final_exits:
+1063 self.add_arc(final_exit.lineno, lineno, cause)
+1064 returns = try_block.return_from
+1065 else:
+1066 returns = self._combine_finally_starts(try_block.return_from, final_exits)
+1067 self.process_return_exits(returns)
+ +1069 if exits:
+1070 # The finally clause's exits are only exits for the try block
+1071 # as a whole if the try block had some exits to begin with.
+1072 exits = final_exits
+ +1074 return exits
+ +1076 @contract(starts='ArcStarts', exits='ArcStarts', returns='ArcStarts')
+1077 def _combine_finally_starts(self, starts, exits):
+1078 """Helper for building the cause of `finally` branches.
+ +1080 "finally" clauses might not execute their exits, and the causes could
+1081 be due to a failure to execute any of the exits in the try block. So
+1082 we use the causes from `starts` as the causes for `exits`.
+1083 """
+1084 causes = []
+1085 for start in sorted(starts):
+1086 if start.cause is not None: 1086 ↛ 1085line 1086 didn't jump to line 1085, because the condition on line 1086 was never false
+1087 causes.append(start.cause.format(lineno=start.lineno))
+1088 cause = " or ".join(causes)
+1089 exits = {ArcStart(xit.lineno, cause) for xit in exits}
+1090 return exits
+ +1092 @contract(returns='ArcStarts')
+1093 def _handle__TryExcept(self, node):
+1094 # Python 2.7 uses separate TryExcept and TryFinally nodes. If we get
+1095 # TryExcept, it means there was no finally, so fake it, and treat as
+1096 # a general Try node.
+1097 node.finalbody = []
+1098 return self._handle__Try(node)
+ +1100 @contract(returns='ArcStarts')
+1101 def _handle__TryFinally(self, node):
+1102 # Python 2.7 uses separate TryExcept and TryFinally nodes. If we get
+1103 # TryFinally, see if there's a TryExcept nested inside. If so, merge
+1104 # them. Otherwise, fake fields to complete a Try node.
+1105 node.handlers = []
+1106 node.orelse = []
+ +1108 first = node.body[0]
+1109 if first.__class__.__name__ == "TryExcept" and node.lineno == first.lineno:
+1110 assert len(node.body) == 1
+1111 node.body = first.body
+1112 node.handlers = first.handlers
+1113 node.orelse = first.orelse
+ +1115 return self._handle__Try(node)
+ +1117 @contract(returns='ArcStarts')
+1118 def _handle__While(self, node):
+1119 start = to_top = self.line_for_node(node.test)
+1120 constant_test = self.is_constant_expr(node.test)
+1121 top_is_body0 = False
+1122 if constant_test and (env.PY3 or constant_test == "Num"):
+1123 top_is_body0 = True
+1124 if env.PYBEHAVIOR.keep_constant_test:
+1125 top_is_body0 = False
+1126 if top_is_body0:
+1127 to_top = self.line_for_node(node.body[0])
+1128 self.block_stack.append(LoopBlock(start=to_top))
+1129 from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
+1130 exits = self.add_body_arcs(node.body, from_start=from_start)
+1131 for xit in exits:
+1132 self.add_arc(xit.lineno, to_top, xit.cause)
+1133 exits = set()
+1134 my_block = self.block_stack.pop()
+1135 exits.update(my_block.break_exits)
+1136 from_start = ArcStart(start, cause="the condition on line {lineno} was never false")
+1137 if node.orelse:
+1138 else_exits = self.add_body_arcs(node.orelse, from_start=from_start)
+1139 exits |= else_exits
+1140 else:
+1141 # No `else` clause: you can exit from the start.
+1142 if not constant_test:
+1143 exits.add(from_start)
+1144 return exits
+ +1146 @contract(returns='ArcStarts')
+1147 def _handle__With(self, node):
+1148 start = self.line_for_node(node)
+1149 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+1150 return exits
+ +1152 _handle__AsyncWith = _handle__With
+ +1154 def _code_object__Module(self, node):
+1155 start = self.line_for_node(node)
+1156 if node.body:
+1157 exits = self.add_body_arcs(node.body, from_start=ArcStart(-start))
+1158 for xit in exits:
+1159 self.add_arc(xit.lineno, -start, xit.cause, "didn't exit the module")
+1160 else:
+1161 # Empty module.
+1162 self.add_arc(-start, start)
+1163 self.add_arc(start, -start)
+ +1165 def _code_object__FunctionDef(self, node):
+1166 start = self.line_for_node(node)
+1167 self.block_stack.append(FunctionBlock(start=start, name=node.name))
+1168 exits = self.add_body_arcs(node.body, from_start=ArcStart(-start))
+1169 self.process_return_exits(exits)
+1170 self.block_stack.pop()
+ +1172 _code_object__AsyncFunctionDef = _code_object__FunctionDef
+ +1174 def _code_object__ClassDef(self, node):
+1175 start = self.line_for_node(node)
+1176 self.add_arc(-start, start)
+1177 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+1178 for xit in exits:
+1179 self.add_arc(
+1180 xit.lineno, -start, xit.cause,
+1181 "didn't exit the body of class {!r}".format(node.name),
+1182 )
+ +1184 def _make_oneline_code_method(noun): # pylint: disable=no-self-argument
+1185 """A function to make methods for online callable _code_object__ methods."""
+1186 def _code_object__oneline_callable(self, node):
+1187 start = self.line_for_node(node)
+1188 self.add_arc(-start, start, None, "didn't run the {} on line {}".format(noun, start))
+1189 self.add_arc(
+1190 start, -start, None,
+1191 "didn't finish the {} on line {}".format(noun, start),
+1192 )
+1193 return _code_object__oneline_callable
+ +1195 _code_object__Lambda = _make_oneline_code_method("lambda")
+1196 _code_object__GeneratorExp = _make_oneline_code_method("generator expression")
+1197 _code_object__DictComp = _make_oneline_code_method("dictionary comprehension")
+1198 _code_object__SetComp = _make_oneline_code_method("set comprehension")
+1199 if env.PY3:
+1200 _code_object__ListComp = _make_oneline_code_method("list comprehension")
+ + +1203if AST_DUMP: # pragma: debugging
+1204 # Code only used when dumping the AST for debugging.
+ +1206 SKIP_DUMP_FIELDS = ["ctx"]
+ +1208 def _is_simple_value(value):
+1209 """Is `value` simple enough to be displayed on a single line?"""
+1210 return (
+1211 value in [None, [], (), {}, set()] or
+1212 isinstance(value, (string_class, int, float))
+1213 )
+ +1215 def ast_dump(node, depth=0):
+1216 """Dump the AST for `node`.
+ +1218 This recursively walks the AST, printing a readable version.
+ +1220 """
+1221 indent = " " * depth
+1222 if not isinstance(node, ast.AST):
+1223 print("{}<{} {!r}>".format(indent, node.__class__.__name__, node))
+1224 return
+ +1226 lineno = getattr(node, "lineno", None)
+1227 if lineno is not None:
+1228 linemark = " @ {},{}".format(node.lineno, node.col_offset)
+1229 if hasattr(node, "end_lineno"):
+1230 linemark += ":"
+1231 if node.end_lineno != node.lineno:
+1232 linemark += "{},".format(node.end_lineno)
+1233 linemark += "{}".format(node.end_col_offset)
+1234 else:
+1235 linemark = ""
+1236 head = "{}<{}{}".format(indent, node.__class__.__name__, linemark)
+ +1238 named_fields = [
+1239 (name, value)
+1240 for name, value in ast.iter_fields(node)
+1241 if name not in SKIP_DUMP_FIELDS
+1242 ]
+1243 if not named_fields:
+1244 print("{}>".format(head))
+1245 elif len(named_fields) == 1 and _is_simple_value(named_fields[0][1]):
+1246 field_name, value = named_fields[0]
+1247 print("{} {}: {!r}>".format(head, field_name, value))
+1248 else:
+1249 print(head)
+1250 if 0:
+1251 print("{}# mro: {}".format(
+1252 indent, ", ".join(c.__name__ for c in node.__class__.__mro__[1:]),
+1253 ))
+1254 next_indent = indent + " "
+1255 for field_name, value in named_fields:
+1256 prefix = "{}{}:".format(next_indent, field_name)
+1257 if _is_simple_value(value):
+1258 print("{} {!r}".format(prefix, value))
+1259 elif isinstance(value, list):
+1260 print("{} [".format(prefix))
+1261 for n in value:
+1262 ast_dump(n, depth + 8)
+1263 print("{}]".format(next_indent))
+1264 else:
+1265 print(prefix)
+1266 ast_dump(value, depth + 8)
+ +1268 print("{}>".format(indent))
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Better tokenizing for coverage.py."""
+ +6import codecs
+7import keyword
+8import re
+9import sys
+10import token
+11import tokenize
+ +13from coverage import env
+14from coverage.backward import iternext, unicode_class
+15from coverage.misc import contract
+ + +18def phys_tokens(toks):
+19 """Return all physical tokens, even line continuations.
+ +21 tokenize.generate_tokens() doesn't return a token for the backslash that
+22 continues lines. This wrapper provides those tokens so that we can
+23 re-create a faithful representation of the original source.
+ +25 Returns the same values as generate_tokens()
+ +27 """
+28 last_line = None
+29 last_lineno = -1
+30 last_ttext = None
+31 for ttype, ttext, (slineno, scol), (elineno, ecol), ltext in toks:
+32 if last_lineno != elineno:
+33 if last_line and last_line.endswith("\\\n"):
+34 # We are at the beginning of a new line, and the last line
+35 # ended with a backslash. We probably have to inject a
+36 # backslash token into the stream. Unfortunately, there's more
+37 # to figure out. This code::
+38 #
+39 # usage = """\
+40 # HEY THERE
+41 # """
+42 #
+43 # triggers this condition, but the token text is::
+44 #
+45 # '"""\\\nHEY THERE\n"""'
+46 #
+47 # so we need to figure out if the backslash is already in the
+48 # string token or not.
+49 inject_backslash = True
+50 if last_ttext.endswith("\\"):
+51 inject_backslash = False
+52 elif ttype == token.STRING:
+53 if "\n" in ttext and ttext.split('\n', 1)[0][-1] == '\\':
+54 # It's a multi-line string and the first line ends with
+55 # a backslash, so we don't need to inject another.
+56 inject_backslash = False
+57 if inject_backslash:
+58 # Figure out what column the backslash is in.
+59 ccol = len(last_line.split("\n")[-2]) - 1
+60 # Yield the token, with a fake token type.
+61 yield (
+62 99999, "\\\n",
+63 (slineno, ccol), (slineno, ccol+2),
+64 last_line
+65 )
+66 last_line = ltext
+67 if ttype not in (tokenize.NEWLINE, tokenize.NL):
+68 last_ttext = ttext
+69 yield ttype, ttext, (slineno, scol), (elineno, ecol), ltext
+70 last_lineno = elineno
+ + +73@contract(source='unicode')
+74def source_token_lines(source):
+75 """Generate a series of lines, one for each line in `source`.
+ +77 Each line is a list of pairs, each pair is a token::
+ +79 [('key', 'def'), ('ws', ' '), ('nam', 'hello'), ('op', '('), ... ]
+ +81 Each pair has a token class, and the token text.
+ +83 If you concatenate all the token texts, and then join them with newlines,
+84 you should have your original `source` back, with two differences:
+85 trailing whitespace is not preserved, and a final line with no newline
+86 is indistinguishable from a final line with a newline.
+ +88 """
+ +90 ws_tokens = {token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL}
+91 line = []
+92 col = 0
+ +94 source = source.expandtabs(8).replace('\r\n', '\n')
+95 tokgen = generate_tokens(source)
+ +97 for ttype, ttext, (_, scol), (_, ecol), _ in phys_tokens(tokgen):
+98 mark_start = True
+99 for part in re.split('(\n)', ttext):
+100 if part == '\n':
+101 yield line
+102 line = []
+103 col = 0
+104 mark_end = False
+105 elif part == '':
+106 mark_end = False
+107 elif ttype in ws_tokens:
+108 mark_end = False
+109 else:
+110 if mark_start and scol > col:
+111 line.append(("ws", u" " * (scol - col)))
+112 mark_start = False
+113 tok_class = tokenize.tok_name.get(ttype, 'xx').lower()[:3]
+114 if ttype == token.NAME and keyword.iskeyword(ttext):
+115 tok_class = "key"
+116 line.append((tok_class, part))
+117 mark_end = True
+118 scol = 0
+119 if mark_end:
+120 col = ecol
+ +122 if line:
+123 yield line
+ + +126class CachedTokenizer(object):
+127 """A one-element cache around tokenize.generate_tokens.
+ +129 When reporting, coverage.py tokenizes files twice, once to find the
+130 structure of the file, and once to syntax-color it. Tokenizing is
+131 expensive, and easily cached.
+ +133 This is a one-element cache so that our twice-in-a-row tokenizing doesn't
+134 actually tokenize twice.
+ +136 """
+137 def __init__(self):
+138 self.last_text = None
+139 self.last_tokens = None
+ +141 @contract(text='unicode')
+142 def generate_tokens(self, text):
+143 """A stand-in for `tokenize.generate_tokens`."""
+144 if text != self.last_text:
+145 self.last_text = text
+146 readline = iternext(text.splitlines(True))
+147 self.last_tokens = list(tokenize.generate_tokens(readline))
+148 return self.last_tokens
+ +150# Create our generate_tokens cache as a callable replacement function.
+151generate_tokens = CachedTokenizer().generate_tokens
+ + +154COOKIE_RE = re.compile(r"^[ \t]*#.*coding[:=][ \t]*([-\w.]+)", flags=re.MULTILINE)
+ +156@contract(source='bytes')
+157def _source_encoding_py2(source):
+158 """Determine the encoding for `source`, according to PEP 263.
+ +160 `source` is a byte string, the text of the program.
+ +162 Returns a string, the name of the encoding.
+ +164 """
+165 assert isinstance(source, bytes)
+ +167 # Do this so the detect_encode code we copied will work.
+168 readline = iternext(source.splitlines(True))
+ +170 # This is mostly code adapted from Py3.2's tokenize module.
+ +172 def _get_normal_name(orig_enc):
+173 """Imitates get_normal_name in tokenizer.c."""
+174 # Only care about the first 12 characters.
+175 enc = orig_enc[:12].lower().replace("_", "-")
+176 if re.match(r"^utf-8($|-)", enc):
+177 return "utf-8"
+178 if re.match(r"^(latin-1|iso-8859-1|iso-latin-1)($|-)", enc):
+179 return "iso-8859-1"
+180 return orig_enc
+ +182 # From detect_encode():
+183 # It detects the encoding from the presence of a UTF-8 BOM or an encoding
+184 # cookie as specified in PEP-0263. If both a BOM and a cookie are present,
+185 # but disagree, a SyntaxError will be raised. If the encoding cookie is an
+186 # invalid charset, raise a SyntaxError. Note that if a UTF-8 BOM is found,
+187 # 'utf-8-sig' is returned.
+ +189 # If no encoding is specified, then the default will be returned.
+190 default = 'ascii'
+ +192 bom_found = False
+193 encoding = None
+ +195 def read_or_stop():
+196 """Get the next source line, or ''."""
+197 try:
+198 return readline()
+199 except StopIteration:
+200 return ''
+ +202 def find_cookie(line):
+203 """Find an encoding cookie in `line`."""
+204 try:
+205 line_string = line.decode('ascii')
+206 except UnicodeDecodeError:
+207 return None
+ +209 matches = COOKIE_RE.findall(line_string)
+210 if not matches:
+211 return None
+212 encoding = _get_normal_name(matches[0])
+213 try:
+214 codec = codecs.lookup(encoding)
+215 except LookupError:
+216 # This behavior mimics the Python interpreter
+217 raise SyntaxError("unknown encoding: " + encoding)
+ +219 if bom_found:
+220 # codecs in 2.3 were raw tuples of functions, assume the best.
+221 codec_name = getattr(codec, 'name', encoding)
+222 if codec_name != 'utf-8':
+223 # This behavior mimics the Python interpreter
+224 raise SyntaxError('encoding problem: utf-8')
+225 encoding += '-sig'
+226 return encoding
+ +228 first = read_or_stop()
+229 if first.startswith(codecs.BOM_UTF8):
+230 bom_found = True
+231 first = first[3:]
+232 default = 'utf-8-sig'
+233 if not first:
+234 return default
+ +236 encoding = find_cookie(first)
+237 if encoding:
+238 return encoding
+ +240 second = read_or_stop()
+241 if not second:
+242 return default
+ +244 encoding = find_cookie(second)
+245 if encoding:
+246 return encoding
+ +248 return default
+ + +251@contract(source='bytes')
+252def _source_encoding_py3(source):
+253 """Determine the encoding for `source`, according to PEP 263.
+ +255 `source` is a byte string: the text of the program.
+ +257 Returns a string, the name of the encoding.
+ +259 """
+260 readline = iternext(source.splitlines(True))
+261 return tokenize.detect_encoding(readline)[0]
+ + +264if env.PY3:
+265 source_encoding = _source_encoding_py3
+266else:
+267 source_encoding = _source_encoding_py2
+ + +270@contract(source='unicode')
+271def compile_unicode(source, filename, mode):
+272 """Just like the `compile` builtin, but works on any Unicode string.
+ +274 Python 2's compile() builtin has a stupid restriction: if the source string
+275 is Unicode, then it may not have a encoding declaration in it. Why not?
+276 Who knows! It also decodes to utf8, and then tries to interpret those utf8
+277 bytes according to the encoding declaration. Why? Who knows!
+ +279 This function neuters the coding declaration, and compiles it.
+ +281 """
+282 source = neuter_encoding_declaration(source)
+283 if env.PY2 and isinstance(filename, unicode_class):
+284 filename = filename.encode(sys.getfilesystemencoding(), "replace")
+285 code = compile(source, filename, mode)
+286 return code
+ + +289@contract(source='unicode', returns='unicode')
+290def neuter_encoding_declaration(source):
+291 """Return `source`, with any encoding declaration neutered."""
+292 if COOKIE_RE.search(source):
+293 source_lines = source.splitlines(True)
+294 for lineno in range(min(2, len(source_lines))):
+295 source_lines[lineno] = COOKIE_RE.sub("# (deleted declaration)", source_lines[lineno])
+296 source = "".join(source_lines)
+297 return source
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""
+5.. versionadded:: 4.0
+ +7Plug-in interfaces for coverage.py.
+ +9Coverage.py supports a few different kinds of plug-ins that change its
+10behavior:
+ +12* File tracers implement tracing of non-Python file types.
+ +14* Configurers add custom configuration, using Python code to change the
+15 configuration.
+ +17* Dynamic context switchers decide when the dynamic context has changed, for
+18 example, to record what test function produced the coverage.
+ +20To write a coverage.py plug-in, create a module with a subclass of
+21:class:`~coverage.CoveragePlugin`. You will override methods in your class to
+22participate in various aspects of coverage.py's processing.
+23Different types of plug-ins have to override different methods.
+ +25Any plug-in can optionally implement :meth:`~coverage.CoveragePlugin.sys_info`
+26to provide debugging information about their operation.
+ +28Your module must also contain a ``coverage_init`` function that registers an
+29instance of your plug-in class::
+ +31 import coverage
+ +33 class MyPlugin(coverage.CoveragePlugin):
+34 ...
+ +36 def coverage_init(reg, options):
+37 reg.add_file_tracer(MyPlugin())
+ +39You use the `reg` parameter passed to your ``coverage_init`` function to
+40register your plug-in object. The registration method you call depends on
+41what kind of plug-in it is.
+ +43If your plug-in takes options, the `options` parameter is a dictionary of your
+44plug-in's options from the coverage.py configuration file. Use them however
+45you want to configure your object before registering it.
+ +47Coverage.py will store its own information on your plug-in object, using
+48attributes whose names start with ``_coverage_``. Don't be startled.
+ +50.. warning::
+51 Plug-ins are imported by coverage.py before it begins measuring code.
+52 If you write a plugin in your own project, it might import your product
+53 code before coverage.py can start measuring. This can result in your
+54 own code being reported as missing.
+ +56 One solution is to put your plugins in your project tree, but not in
+57 your importable Python package.
+ + +60.. _file_tracer_plugins:
+ +62File Tracers
+63============
+ +65File tracers implement measurement support for non-Python files. File tracers
+66implement the :meth:`~coverage.CoveragePlugin.file_tracer` method to claim
+67files and the :meth:`~coverage.CoveragePlugin.file_reporter` method to report
+68on those files.
+ +70In your ``coverage_init`` function, use the ``add_file_tracer`` method to
+71register your file tracer.
+ + +74.. _configurer_plugins:
+ +76Configurers
+77===========
+ +79.. versionadded:: 4.5
+ +81Configurers modify the configuration of coverage.py during start-up.
+82Configurers implement the :meth:`~coverage.CoveragePlugin.configure` method to
+83change the configuration.
+ +85In your ``coverage_init`` function, use the ``add_configurer`` method to
+86register your configurer.
+ + +89.. _dynamic_context_plugins:
+ +91Dynamic Context Switchers
+92=========================
+ +94.. versionadded:: 5.0
+ +96Dynamic context switcher plugins implement the
+97:meth:`~coverage.CoveragePlugin.dynamic_context` method to dynamically compute
+98the context label for each measured frame.
+ +100Computed context labels are useful when you want to group measured data without
+101modifying the source code.
+ +103For example, you could write a plugin that checks `frame.f_code` to inspect
+104the currently executed method, and set the context label to a fully qualified
+105method name if it's an instance method of `unittest.TestCase` and the method
+106name starts with 'test'. Such a plugin would provide basic coverage grouping
+107by test and could be used with test runners that have no built-in coveragepy
+108support.
+ +110In your ``coverage_init`` function, use the ``add_dynamic_context`` method to
+111register your dynamic context switcher.
+ +113"""
+ +115from coverage import files
+116from coverage.misc import contract, _needs_to_implement
+ + +119class CoveragePlugin(object):
+120 """Base class for coverage.py plug-ins."""
+ +122 def file_tracer(self, filename): # pylint: disable=unused-argument
+123 """Get a :class:`FileTracer` object for a file.
+ +125 Plug-in type: file tracer.
+ +127 Every Python source file is offered to your plug-in to give it a chance
+128 to take responsibility for tracing the file. If your plug-in can
+129 handle the file, it should return a :class:`FileTracer` object.
+130 Otherwise return None.
+ +132 There is no way to register your plug-in for particular files.
+133 Instead, this method is invoked for all files as they are executed,
+134 and the plug-in decides whether it can trace the file or not.
+135 Be prepared for `filename` to refer to all kinds of files that have
+136 nothing to do with your plug-in.
+ +138 The file name will be a Python file being executed. There are two
+139 broad categories of behavior for a plug-in, depending on the kind of
+140 files your plug-in supports:
+ +142 * Static file names: each of your original source files has been
+143 converted into a distinct Python file. Your plug-in is invoked with
+144 the Python file name, and it maps it back to its original source
+145 file.
+ +147 * Dynamic file names: all of your source files are executed by the same
+148 Python file. In this case, your plug-in implements
+149 :meth:`FileTracer.dynamic_source_filename` to provide the actual
+150 source file for each execution frame.
+ +152 `filename` is a string, the path to the file being considered. This is
+153 the absolute real path to the file. If you are comparing to other
+154 paths, be sure to take this into account.
+ +156 Returns a :class:`FileTracer` object to use to trace `filename`, or
+157 None if this plug-in cannot trace this file.
+ +159 """
+160 return None
+ +162 def file_reporter(self, filename): # pylint: disable=unused-argument
+163 """Get the :class:`FileReporter` class to use for a file.
+ +165 Plug-in type: file tracer.
+ +167 This will only be invoked if `filename` returns non-None from
+168 :meth:`file_tracer`. It's an error to return None from this method.
+ +170 Returns a :class:`FileReporter` object to use to report on `filename`,
+171 or the string `"python"` to have coverage.py treat the file as Python.
+ +173 """
+174 _needs_to_implement(self, "file_reporter")
+ +176 def dynamic_context(self, frame): # pylint: disable=unused-argument
+177 """Get the dynamically computed context label for `frame`.
+ +179 Plug-in type: dynamic context.
+ +181 This method is invoked for each frame when outside of a dynamic
+182 context, to see if a new dynamic context should be started. If it
+183 returns a string, a new context label is set for this and deeper
+184 frames. The dynamic context ends when this frame returns.
+ +186 Returns a string to start a new dynamic context, or None if no new
+187 context should be started.
+ +189 """
+190 return None
+ +192 def find_executable_files(self, src_dir): # pylint: disable=unused-argument
+193 """Yield all of the executable files in `src_dir`, recursively.
+ +195 Plug-in type: file tracer.
+ +197 Executability is a plug-in-specific property, but generally means files
+198 which would have been considered for coverage analysis, had they been
+199 included automatically.
+ +201 Returns or yields a sequence of strings, the paths to files that could
+202 have been executed, including files that had been executed.
+ +204 """
+205 return []
+ +207 def configure(self, config):
+208 """Modify the configuration of coverage.py.
+ +210 Plug-in type: configurer.
+ +212 This method is called during coverage.py start-up, to give your plug-in
+213 a chance to change the configuration. The `config` parameter is an
+214 object with :meth:`~coverage.Coverage.get_option` and
+215 :meth:`~coverage.Coverage.set_option` methods. Do not call any other
+216 methods on the `config` object.
+ +218 """
+219 pass
+ +221 def sys_info(self):
+222 """Get a list of information useful for debugging.
+ +224 Plug-in type: any.
+ +226 This method will be invoked for ``--debug=sys``. Your
+227 plug-in can return any information it wants to be displayed.
+ +229 Returns a list of pairs: `[(name, value), ...]`.
+ +231 """
+232 return []
+ + +235class FileTracer(object):
+236 """Support needed for files during the execution phase.
+ +238 File tracer plug-ins implement subclasses of FileTracer to return from
+239 their :meth:`~CoveragePlugin.file_tracer` method.
+ +241 You may construct this object from :meth:`CoveragePlugin.file_tracer` any
+242 way you like. A natural choice would be to pass the file name given to
+243 `file_tracer`.
+ +245 `FileTracer` objects should only be created in the
+246 :meth:`CoveragePlugin.file_tracer` method.
+ +248 See :ref:`howitworks` for details of the different coverage.py phases.
+ +250 """
+ +252 def source_filename(self):
+253 """The source file name for this file.
+ +255 This may be any file name you like. A key responsibility of a plug-in
+256 is to own the mapping from Python execution back to whatever source
+257 file name was originally the source of the code.
+ +259 See :meth:`CoveragePlugin.file_tracer` for details about static and
+260 dynamic file names.
+ +262 Returns the file name to credit with this execution.
+ +264 """
+265 _needs_to_implement(self, "source_filename")
+ +267 def has_dynamic_source_filename(self):
+268 """Does this FileTracer have dynamic source file names?
+ +270 FileTracers can provide dynamically determined file names by
+271 implementing :meth:`dynamic_source_filename`. Invoking that function
+272 is expensive. To determine whether to invoke it, coverage.py uses the
+273 result of this function to know if it needs to bother invoking
+274 :meth:`dynamic_source_filename`.
+ +276 See :meth:`CoveragePlugin.file_tracer` for details about static and
+277 dynamic file names.
+ +279 Returns True if :meth:`dynamic_source_filename` should be called to get
+280 dynamic source file names.
+ +282 """
+283 return False
+ +285 def dynamic_source_filename(self, filename, frame): # pylint: disable=unused-argument
+286 """Get a dynamically computed source file name.
+ +288 Some plug-ins need to compute the source file name dynamically for each
+289 frame.
+ +291 This function will not be invoked if
+292 :meth:`has_dynamic_source_filename` returns False.
+ +294 Returns the source file name for this frame, or None if this frame
+295 shouldn't be measured.
+ +297 """
+298 return None
+ +300 def line_number_range(self, frame):
+301 """Get the range of source line numbers for a given a call frame.
+ +303 The call frame is examined, and the source line number in the original
+304 file is returned. The return value is a pair of numbers, the starting
+305 line number and the ending line number, both inclusive. For example,
+306 returning (5, 7) means that lines 5, 6, and 7 should be considered
+307 executed.
+ +309 This function might decide that the frame doesn't indicate any lines
+310 from the source file were executed. Return (-1, -1) in this case to
+311 tell coverage.py that no lines should be recorded for this frame.
+ +313 """
+314 lineno = frame.f_lineno
+315 return lineno, lineno
+ + +318class FileReporter(object):
+319 """Support needed for files during the analysis and reporting phases.
+ +321 File tracer plug-ins implement a subclass of `FileReporter`, and return
+322 instances from their :meth:`CoveragePlugin.file_reporter` method.
+ +324 There are many methods here, but only :meth:`lines` is required, to provide
+325 the set of executable lines in the file.
+ +327 See :ref:`howitworks` for details of the different coverage.py phases.
+ +329 """
+ +331 def __init__(self, filename):
+332 """Simple initialization of a `FileReporter`.
+ +334 The `filename` argument is the path to the file being reported. This
+335 will be available as the `.filename` attribute on the object. Other
+336 method implementations on this base class rely on this attribute.
+ +338 """
+339 self.filename = filename
+ +341 def __repr__(self):
+342 return "<{0.__class__.__name__} filename={0.filename!r}>".format(self)
+ +344 def relative_filename(self):
+345 """Get the relative file name for this file.
+ +347 This file path will be displayed in reports. The default
+348 implementation will supply the actual project-relative file path. You
+349 only need to supply this method if you have an unusual syntax for file
+350 paths.
+ +352 """
+353 return files.relative_filename(self.filename)
+ +355 @contract(returns='unicode')
+356 def source(self):
+357 """Get the source for the file.
+ +359 Returns a Unicode string.
+ +361 The base implementation simply reads the `self.filename` file and
+362 decodes it as UTF8. Override this method if your file isn't readable
+363 as a text file, or if you need other encoding support.
+ +365 """
+366 with open(self.filename, "rb") as f:
+367 return f.read().decode("utf8")
+ +369 def lines(self):
+370 """Get the executable lines in this file.
+ +372 Your plug-in must determine which lines in the file were possibly
+373 executable. This method returns a set of those line numbers.
+ +375 Returns a set of line numbers.
+ +377 """
+378 _needs_to_implement(self, "lines")
+ +380 def excluded_lines(self):
+381 """Get the excluded executable lines in this file.
+ +383 Your plug-in can use any method it likes to allow the user to exclude
+384 executable lines from consideration.
+ +386 Returns a set of line numbers.
+ +388 The base implementation returns the empty set.
+ +390 """
+391 return set()
+ +393 def translate_lines(self, lines):
+394 """Translate recorded lines into reported lines.
+ +396 Some file formats will want to report lines slightly differently than
+397 they are recorded. For example, Python records the last line of a
+398 multi-line statement, but reports are nicer if they mention the first
+399 line.
+ +401 Your plug-in can optionally define this method to perform these kinds
+402 of adjustment.
+ +404 `lines` is a sequence of integers, the recorded line numbers.
+ +406 Returns a set of integers, the adjusted line numbers.
+ +408 The base implementation returns the numbers unchanged.
+ +410 """
+411 return set(lines)
+ +413 def arcs(self):
+414 """Get the executable arcs in this file.
+ +416 To support branch coverage, your plug-in needs to be able to indicate
+417 possible execution paths, as a set of line number pairs. Each pair is
+418 a `(prev, next)` pair indicating that execution can transition from the
+419 `prev` line number to the `next` line number.
+ +421 Returns a set of pairs of line numbers. The default implementation
+422 returns an empty set.
+ +424 """
+425 return set()
+ +427 def no_branch_lines(self):
+428 """Get the lines excused from branch coverage in this file.
+ +430 Your plug-in can use any method it likes to allow the user to exclude
+431 lines from consideration of branch coverage.
+ +433 Returns a set of line numbers.
+ +435 The base implementation returns the empty set.
+ +437 """
+438 return set()
+ +440 def translate_arcs(self, arcs):
+441 """Translate recorded arcs into reported arcs.
+ +443 Similar to :meth:`translate_lines`, but for arcs. `arcs` is a set of
+444 line number pairs.
+ +446 Returns a set of line number pairs.
+ +448 The default implementation returns `arcs` unchanged.
+ +450 """
+451 return arcs
+ +453 def exit_counts(self):
+454 """Get a count of exits from that each line.
+ +456 To determine which lines are branches, coverage.py looks for lines that
+457 have more than one exit. This function creates a dict mapping each
+458 executable line number to a count of how many exits it has.
+ +460 To be honest, this feels wrong, and should be refactored. Let me know
+461 if you attempt to implement this method in your plug-in...
+ +463 """
+464 return {}
+ +466 def missing_arc_description(self, start, end, executed_arcs=None): # pylint: disable=unused-argument
+467 """Provide an English sentence describing a missing arc.
+ +469 The `start` and `end` arguments are the line numbers of the missing
+470 arc. Negative numbers indicate entering or exiting code objects.
+ +472 The `executed_arcs` argument is a set of line number pairs, the arcs
+473 that were executed in this file.
+ +475 By default, this simply returns the string "Line {start} didn't jump
+476 to {end}".
+ +478 """
+479 return "Line {start} didn't jump to line {end}".format(start=start, end=end)
+ +481 def source_token_lines(self):
+482 """Generate a series of tokenized lines, one for each line in `source`.
+ +484 These tokens are used for syntax-colored reports.
+ +486 Each line is a list of pairs, each pair is a token::
+ +488 [('key', 'def'), ('ws', ' '), ('nam', 'hello'), ('op', '('), ... ]
+ +490 Each pair has a token class, and the token text. The token classes
+491 are:
+ +493 * ``'com'``: a comment
+494 * ``'key'``: a keyword
+495 * ``'nam'``: a name, or identifier
+496 * ``'num'``: a number
+497 * ``'op'``: an operator
+498 * ``'str'``: a string literal
+499 * ``'ws'``: some white space
+500 * ``'txt'``: some other kind of text
+ +502 If you concatenate all the token texts, and then join them with
+503 newlines, you should have your original source back.
+ +505 The default implementation simply returns each line tagged as
+506 ``'txt'``.
+ +508 """
+509 for line in self.source().splitlines():
+510 yield [('txt', line)]
+ +512 # Annoying comparison operators. Py3k wants __lt__ etc, and Py2k needs all
+513 # of them defined.
+ +515 def __eq__(self, other):
+516 return isinstance(other, FileReporter) and self.filename == other.filename
+ +518 def __ne__(self, other):
+519 return not (self == other)
+ +521 def __lt__(self, other):
+522 return self.filename < other.filename
+ +524 def __le__(self, other):
+525 return self.filename <= other.filename
+ +527 def __gt__(self, other):
+528 return self.filename > other.filename
+ +530 def __ge__(self, other):
+531 return self.filename >= other.filename
+ +533 __hash__ = None # This object doesn't need to be hashed.
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Support for plugins."""
+ +6import os
+7import os.path
+8import sys
+ +10from coverage.misc import CoverageException, isolate_module
+11from coverage.plugin import CoveragePlugin, FileTracer, FileReporter
+ +13os = isolate_module(os)
+ + +16class Plugins(object):
+17 """The currently loaded collection of coverage.py plugins."""
+ +19 def __init__(self):
+20 self.order = []
+21 self.names = {}
+22 self.file_tracers = []
+23 self.configurers = []
+24 self.context_switchers = []
+ +26 self.current_module = None
+27 self.debug = None
+ +29 @classmethod
+30 def load_plugins(cls, modules, config, debug=None):
+31 """Load plugins from `modules`.
+ +33 Returns a Plugins object with the loaded and configured plugins.
+ +35 """
+36 plugins = cls()
+37 plugins.debug = debug
+ +39 for module in modules:
+40 plugins.current_module = module
+41 __import__(module)
+42 mod = sys.modules[module]
+ +44 coverage_init = getattr(mod, "coverage_init", None)
+45 if not coverage_init:
+46 raise CoverageException(
+47 "Plugin module %r didn't define a coverage_init function" % module
+48 )
+ +50 options = config.get_plugin_options(module)
+51 coverage_init(plugins, options)
+ +53 plugins.current_module = None
+54 return plugins
+ +56 def add_file_tracer(self, plugin):
+57 """Add a file tracer plugin.
+ +59 `plugin` is an instance of a third-party plugin class. It must
+60 implement the :meth:`CoveragePlugin.file_tracer` method.
+ +62 """
+63 self._add_plugin(plugin, self.file_tracers)
+ +65 def add_configurer(self, plugin):
+66 """Add a configuring plugin.
+ +68 `plugin` is an instance of a third-party plugin class. It must
+69 implement the :meth:`CoveragePlugin.configure` method.
+ +71 """
+72 self._add_plugin(plugin, self.configurers)
+ +74 def add_dynamic_context(self, plugin):
+75 """Add a dynamic context plugin.
+ +77 `plugin` is an instance of a third-party plugin class. It must
+78 implement the :meth:`CoveragePlugin.dynamic_context` method.
+ +80 """
+81 self._add_plugin(plugin, self.context_switchers)
+ +83 def add_noop(self, plugin):
+84 """Add a plugin that does nothing.
+ +86 This is only useful for testing the plugin support.
+ +88 """
+89 self._add_plugin(plugin, None)
+ +91 def _add_plugin(self, plugin, specialized):
+92 """Add a plugin object.
+ +94 `plugin` is a :class:`CoveragePlugin` instance to add. `specialized`
+95 is a list to append the plugin to.
+ +97 """
+98 plugin_name = "%s.%s" % (self.current_module, plugin.__class__.__name__)
+99 if self.debug and self.debug.should('plugin'): 99 ↛ 100line 99 didn't jump to line 100, because the condition on line 99 was never true
+100 self.debug.write("Loaded plugin %r: %r" % (self.current_module, plugin))
+101 labelled = LabelledDebug("plugin %r" % (self.current_module,), self.debug)
+102 plugin = DebugPluginWrapper(plugin, labelled)
+ +104 # pylint: disable=attribute-defined-outside-init
+105 plugin._coverage_plugin_name = plugin_name
+106 plugin._coverage_enabled = True
+107 self.order.append(plugin)
+108 self.names[plugin_name] = plugin
+109 if specialized is not None:
+110 specialized.append(plugin)
+ +112 def __nonzero__(self):
+113 return bool(self.order)
+ +115 __bool__ = __nonzero__
+ +117 def __iter__(self):
+118 return iter(self.order)
+ +120 def get(self, plugin_name):
+121 """Return a plugin by name."""
+122 return self.names[plugin_name]
+ + +125class LabelledDebug(object):
+126 """A Debug writer, but with labels for prepending to the messages."""
+ +128 def __init__(self, label, debug, prev_labels=()):
+129 self.labels = list(prev_labels) + [label]
+130 self.debug = debug
+ +132 def add_label(self, label):
+133 """Add a label to the writer, and return a new `LabelledDebug`."""
+134 return LabelledDebug(label, self.debug, self.labels)
+ +136 def message_prefix(self):
+137 """The prefix to use on messages, combining the labels."""
+138 prefixes = self.labels + ['']
+139 return ":\n".join(" "*i+label for i, label in enumerate(prefixes))
+ +141 def write(self, message):
+142 """Write `message`, but with the labels prepended."""
+143 self.debug.write("%s%s" % (self.message_prefix(), message))
+ + +146class DebugPluginWrapper(CoveragePlugin):
+147 """Wrap a plugin, and use debug to report on what it's doing."""
+ +149 def __init__(self, plugin, debug):
+150 super(DebugPluginWrapper, self).__init__()
+151 self.plugin = plugin
+152 self.debug = debug
+ +154 def file_tracer(self, filename):
+155 tracer = self.plugin.file_tracer(filename)
+156 self.debug.write("file_tracer(%r) --> %r" % (filename, tracer))
+157 if tracer:
+158 debug = self.debug.add_label("file %r" % (filename,))
+159 tracer = DebugFileTracerWrapper(tracer, debug)
+160 return tracer
+ +162 def file_reporter(self, filename):
+163 reporter = self.plugin.file_reporter(filename)
+164 self.debug.write("file_reporter(%r) --> %r" % (filename, reporter))
+165 if reporter:
+166 debug = self.debug.add_label("file %r" % (filename,))
+167 reporter = DebugFileReporterWrapper(filename, reporter, debug)
+168 return reporter
+ +170 def dynamic_context(self, frame):
+171 context = self.plugin.dynamic_context(frame)
+172 self.debug.write("dynamic_context(%r) --> %r" % (frame, context))
+173 return context
+ +175 def find_executable_files(self, src_dir):
+176 executable_files = self.plugin.find_executable_files(src_dir)
+177 self.debug.write("find_executable_files(%r) --> %r" % (src_dir, executable_files))
+178 return executable_files
+ +180 def configure(self, config):
+181 self.debug.write("configure(%r)" % (config,))
+182 self.plugin.configure(config)
+ +184 def sys_info(self):
+185 return self.plugin.sys_info()
+ + +188class DebugFileTracerWrapper(FileTracer):
+189 """A debugging `FileTracer`."""
+ +191 def __init__(self, tracer, debug):
+192 self.tracer = tracer
+193 self.debug = debug
+ +195 def _show_frame(self, frame):
+196 """A short string identifying a frame, for debug messages."""
+197 return "%s@%d" % (
+198 os.path.basename(frame.f_code.co_filename),
+199 frame.f_lineno,
+200 )
+ +202 def source_filename(self):
+203 sfilename = self.tracer.source_filename()
+204 self.debug.write("source_filename() --> %r" % (sfilename,))
+205 return sfilename
+ +207 def has_dynamic_source_filename(self):
+208 has = self.tracer.has_dynamic_source_filename()
+209 self.debug.write("has_dynamic_source_filename() --> %r" % (has,))
+210 return has
+ +212 def dynamic_source_filename(self, filename, frame):
+213 dyn = self.tracer.dynamic_source_filename(filename, frame)
+214 self.debug.write("dynamic_source_filename(%r, %s) --> %r" % (
+215 filename, self._show_frame(frame), dyn,
+216 ))
+217 return dyn
+ +219 def line_number_range(self, frame):
+220 pair = self.tracer.line_number_range(frame)
+221 self.debug.write("line_number_range(%s) --> %r" % (self._show_frame(frame), pair))
+222 return pair
+ + +225class DebugFileReporterWrapper(FileReporter):
+226 """A debugging `FileReporter`."""
+ +228 def __init__(self, filename, reporter, debug):
+229 super(DebugFileReporterWrapper, self).__init__(filename)
+230 self.reporter = reporter
+231 self.debug = debug
+ +233 def relative_filename(self):
+234 ret = self.reporter.relative_filename()
+235 self.debug.write("relative_filename() --> %r" % (ret,))
+236 return ret
+ +238 def lines(self):
+239 ret = self.reporter.lines()
+240 self.debug.write("lines() --> %r" % (ret,))
+241 return ret
+ +243 def excluded_lines(self):
+244 ret = self.reporter.excluded_lines()
+245 self.debug.write("excluded_lines() --> %r" % (ret,))
+246 return ret
+ +248 def translate_lines(self, lines):
+249 ret = self.reporter.translate_lines(lines)
+250 self.debug.write("translate_lines(%r) --> %r" % (lines, ret))
+251 return ret
+ +253 def translate_arcs(self, arcs):
+254 ret = self.reporter.translate_arcs(arcs)
+255 self.debug.write("translate_arcs(%r) --> %r" % (arcs, ret))
+256 return ret
+ +258 def no_branch_lines(self):
+259 ret = self.reporter.no_branch_lines()
+260 self.debug.write("no_branch_lines() --> %r" % (ret,))
+261 return ret
+ +263 def exit_counts(self):
+264 ret = self.reporter.exit_counts()
+265 self.debug.write("exit_counts() --> %r" % (ret,))
+266 return ret
+ +268 def arcs(self):
+269 ret = self.reporter.arcs()
+270 self.debug.write("arcs() --> %r" % (ret,))
+271 return ret
+ +273 def source(self):
+274 ret = self.reporter.source()
+275 self.debug.write("source() --> %d chars" % (len(ret),))
+276 return ret
+ +278 def source_token_lines(self):
+279 ret = list(self.reporter.source_token_lines())
+280 self.debug.write("source_token_lines() --> %d tokens" % (len(ret),))
+281 return ret
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Python source expertise for coverage.py"""
+ +6import os.path
+7import types
+8import zipimport
+ +10from coverage import env, files
+11from coverage.misc import contract, expensive, isolate_module, join_regex
+12from coverage.misc import CoverageException, NoSource
+13from coverage.parser import PythonParser
+14from coverage.phystokens import source_token_lines, source_encoding
+15from coverage.plugin import FileReporter
+ +17os = isolate_module(os)
+ + +20@contract(returns='bytes')
+21def read_python_source(filename):
+22 """Read the Python source text from `filename`.
+ +24 Returns bytes.
+ +26 """
+27 with open(filename, "rb") as f:
+28 source = f.read()
+ +30 if env.IRONPYTHON:
+31 # IronPython reads Unicode strings even for "rb" files.
+32 source = bytes(source)
+ +34 return source.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
+ + +37@contract(returns='unicode')
+38def get_python_source(filename):
+39 """Return the source code, as unicode."""
+40 base, ext = os.path.splitext(filename)
+41 if ext == ".py" and env.WINDOWS:
+42 exts = [".py", ".pyw"]
+43 else:
+44 exts = [ext]
+ +46 for ext in exts:
+47 try_filename = base + ext
+48 if os.path.exists(try_filename):
+49 # A regular text file: open it.
+50 source = read_python_source(try_filename)
+51 break
+ +53 # Maybe it's in a zip file?
+54 source = get_zip_bytes(try_filename)
+55 if source is not None:
+56 break
+57 else:
+58 # Couldn't find source.
+59 exc_msg = "No source for code: '%s'.\n" % (filename,)
+60 exc_msg += "Aborting report output, consider using -i."
+61 raise NoSource(exc_msg)
+ +63 # Replace \f because of http://bugs.python.org/issue19035
+64 source = source.replace(b'\f', b' ')
+65 source = source.decode(source_encoding(source), "replace")
+ +67 # Python code should always end with a line with a newline.
+68 if source and source[-1] != '\n':
+69 source += '\n'
+ +71 return source
+ + +74@contract(returns='bytes|None')
+75def get_zip_bytes(filename):
+76 """Get data from `filename` if it is a zip file path.
+ +78 Returns the bytestring data read from the zip file, or None if no zip file
+79 could be found or `filename` isn't in it. The data returned will be
+80 an empty string if the file is empty.
+ +82 """
+83 markers = ['.zip'+os.sep, '.egg'+os.sep, '.pex'+os.sep]
+84 for marker in markers:
+85 if marker in filename:
+86 parts = filename.split(marker)
+87 try:
+88 zi = zipimport.zipimporter(parts[0]+marker[:-1])
+89 except zipimport.ZipImportError:
+90 continue
+91 try:
+92 data = zi.get_data(parts[1])
+93 except IOError:
+94 continue
+95 return data
+96 return None
+ + +99def source_for_file(filename):
+100 """Return the source filename for `filename`.
+ +102 Given a file name being traced, return the best guess as to the source
+103 file to attribute it to.
+ +105 """
+106 if filename.endswith(".py"):
+107 # .py files are themselves source files.
+108 return filename
+ +110 elif filename.endswith((".pyc", ".pyo")):
+111 # Bytecode files probably have source files near them.
+112 py_filename = filename[:-1]
+113 if os.path.exists(py_filename):
+114 # Found a .py file, use that.
+115 return py_filename
+116 if env.WINDOWS:
+117 # On Windows, it could be a .pyw file.
+118 pyw_filename = py_filename + "w"
+119 if os.path.exists(pyw_filename):
+120 return pyw_filename
+121 # Didn't find source, but it's probably the .py file we want.
+122 return py_filename
+ +124 elif filename.endswith("$py.class"):
+125 # Jython is easy to guess.
+126 return filename[:-9] + ".py"
+ +128 # No idea, just use the file name as-is.
+129 return filename
+ + +132def source_for_morf(morf):
+133 """Get the source filename for the module-or-file `morf`."""
+134 if hasattr(morf, '__file__') and morf.__file__:
+135 filename = morf.__file__
+136 elif isinstance(morf, types.ModuleType):
+137 # A module should have had .__file__, otherwise we can't use it.
+138 # This could be a PEP-420 namespace package.
+139 raise CoverageException("Module {} has no file".format(morf))
+140 else:
+141 filename = morf
+ +143 filename = source_for_file(files.unicode_filename(filename))
+144 return filename
+ + +147class PythonFileReporter(FileReporter):
+148 """Report support for a Python file."""
+ +150 def __init__(self, morf, coverage=None):
+151 self.coverage = coverage
+ +153 filename = source_for_morf(morf)
+ +155 super(PythonFileReporter, self).__init__(files.canonical_filename(filename))
+ +157 if hasattr(morf, '__name__'):
+158 name = morf.__name__.replace(".", os.sep)
+159 if os.path.basename(filename).startswith('__init__.'):
+160 name += os.sep + "__init__"
+161 name += ".py"
+162 name = files.unicode_filename(name)
+163 else:
+164 name = files.relative_filename(filename)
+165 self.relname = name
+ +167 self._source = None
+168 self._parser = None
+169 self._excluded = None
+ +171 def __repr__(self):
+172 return "<PythonFileReporter {!r}>".format(self.filename)
+ +174 @contract(returns='unicode')
+175 def relative_filename(self):
+176 return self.relname
+ +178 @property
+179 def parser(self):
+180 """Lazily create a :class:`PythonParser`."""
+181 if self._parser is None:
+182 self._parser = PythonParser(
+183 filename=self.filename,
+184 exclude=self.coverage._exclude_regex('exclude'),
+185 )
+186 self._parser.parse_source()
+187 return self._parser
+ +189 def lines(self):
+190 """Return the line numbers of statements in the file."""
+191 return self.parser.statements
+ +193 def excluded_lines(self):
+194 """Return the line numbers of statements in the file."""
+195 return self.parser.excluded
+ +197 def translate_lines(self, lines):
+198 return self.parser.translate_lines(lines)
+ +200 def translate_arcs(self, arcs):
+201 return self.parser.translate_arcs(arcs)
+ +203 @expensive
+204 def no_branch_lines(self):
+205 no_branch = self.parser.lines_matching(
+206 join_regex(self.coverage.config.partial_list),
+207 join_regex(self.coverage.config.partial_always_list)
+208 )
+209 return no_branch
+ +211 @expensive
+212 def arcs(self):
+213 return self.parser.arcs()
+ +215 @expensive
+216 def exit_counts(self):
+217 return self.parser.exit_counts()
+ +219 def missing_arc_description(self, start, end, executed_arcs=None):
+220 return self.parser.missing_arc_description(start, end, executed_arcs)
+ +222 @contract(returns='unicode')
+223 def source(self):
+224 if self._source is None:
+225 self._source = get_python_source(self.filename)
+226 return self._source
+ +228 def should_be_python(self):
+229 """Does it seem like this file should contain Python?
+ +231 This is used to decide if a file reported as part of the execution of
+232 a program was really likely to have contained Python in the first
+233 place.
+ +235 """
+236 # Get the file extension.
+237 _, ext = os.path.splitext(self.filename)
+ +239 # Anything named *.py* should be Python.
+240 if ext.startswith('.py'):
+241 return True
+242 # A file with no extension should be Python.
+243 if not ext: 243 ↛ 244line 243 didn't jump to line 244, because the condition on line 243 was never true
+244 return True
+245 # Everything else is probably not Python.
+246 return False
+ +248 def source_token_lines(self):
+249 return source_token_lines(self.source())
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Raw data collector for coverage.py."""
+ +6import atexit
+7import dis
+8import sys
+ +10from coverage import env
+ +12# We need the YIELD_VALUE opcode below, in a comparison-friendly form.
+13YIELD_VALUE = dis.opmap['YIELD_VALUE']
+14if env.PY2:
+15 YIELD_VALUE = chr(YIELD_VALUE)
+ +17# When running meta-coverage, this file can try to trace itself, which confuses
+18# everything. Don't trace ourselves.
+ +20THIS_FILE = __file__.rstrip("co")
+ + +23class PyTracer(object):
+24 """Python implementation of the raw data tracer."""
+ +26 # Because of poor implementations of trace-function-manipulating tools,
+27 # the Python trace function must be kept very simple. In particular, there
+28 # must be only one function ever set as the trace function, both through
+29 # sys.settrace, and as the return value from the trace function. Put
+30 # another way, the trace function must always return itself. It cannot
+31 # swap in other functions, or return None to avoid tracing a particular
+32 # frame.
+33 #
+34 # The trace manipulator that introduced this restriction is DecoratorTools,
+35 # which sets a trace function, and then later restores the pre-existing one
+36 # by calling sys.settrace with a function it found in the current frame.
+37 #
+38 # Systems that use DecoratorTools (or similar trace manipulations) must use
+39 # PyTracer to get accurate results. The command-line --timid argument is
+40 # used to force the use of this tracer.
+ +42 def __init__(self):
+43 # Attributes set from the collector:
+44 self.data = None
+45 self.trace_arcs = False
+46 self.should_trace = None
+47 self.should_trace_cache = None
+48 self.should_start_context = None
+49 self.warn = None
+50 # The threading module to use, if any.
+51 self.threading = None
+ +53 self.cur_file_dict = None
+54 self.last_line = 0 # int, but uninitialized.
+55 self.cur_file_name = None
+56 self.context = None
+57 self.started_context = False
+ +59 self.data_stack = []
+60 self.last_exc_back = None
+61 self.last_exc_firstlineno = 0
+62 self.thread = None
+63 self.stopped = False
+64 self._activity = False
+ +66 self.in_atexit = False
+67 # On exit, self.in_atexit = True
+68 atexit.register(setattr, self, 'in_atexit', True)
+ +70 def __repr__(self):
+71 return "<PyTracer at {}: {} lines in {} files>".format(
+72 id(self),
+73 sum(len(v) for v in self.data.values()),
+74 len(self.data),
+75 )
+ +77 def log(self, marker, *args):
+78 """For hard-core logging of what this tracer is doing."""
+79 with open("/tmp/debug_trace.txt", "a") as f:
+80 f.write("{} {}[{}]".format(
+81 marker,
+82 id(self),
+83 len(self.data_stack),
+84 ))
+85 if 0:
+86 f.write(".{:x}.{:x}".format(
+87 self.thread.ident,
+88 self.threading.currentThread().ident,
+89 ))
+90 f.write(" {}".format(" ".join(map(str, args))))
+91 if 0:
+92 f.write(" | ")
+93 stack = " / ".join(
+94 (fname or "???").rpartition("/")[-1]
+95 for _, fname, _, _ in self.data_stack
+96 )
+97 f.write(stack)
+98 f.write("\n")
+ +100 def _trace(self, frame, event, arg_unused):
+101 """The trace function passed to sys.settrace."""
+ +103 if THIS_FILE in frame.f_code.co_filename:
+104 return None
+ +106 #self.log(":", frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name + "()", event)
+ +108 if (self.stopped and sys.gettrace() == self._trace): # pylint: disable=comparison-with-callable
+109 # The PyTrace.stop() method has been called, possibly by another
+110 # thread, let's deactivate ourselves now.
+111 if 0:
+112 self.log("---\nX", frame.f_code.co_filename, frame.f_lineno)
+113 f = frame
+114 while f:
+115 self.log(">", f.f_code.co_filename, f.f_lineno, f.f_code.co_name, f.f_trace)
+116 f = f.f_back
+117 sys.settrace(None)
+118 self.cur_file_dict, self.cur_file_name, self.last_line, self.started_context = (
+119 self.data_stack.pop()
+120 )
+121 return None
+ +123 if self.last_exc_back:
+124 if frame == self.last_exc_back:
+125 # Someone forgot a return event.
+126 if self.trace_arcs and self.cur_file_dict:
+127 pair = (self.last_line, -self.last_exc_firstlineno)
+128 self.cur_file_dict[pair] = None
+129 self.cur_file_dict, self.cur_file_name, self.last_line, self.started_context = (
+130 self.data_stack.pop()
+131 )
+132 self.last_exc_back = None
+ +134 # if event != 'call' and frame.f_code.co_filename != self.cur_file_name:
+135 # self.log("---\n*", frame.f_code.co_filename, self.cur_file_name, frame.f_lineno)
+ +137 if event == 'call':
+138 # Should we start a new context?
+139 if self.should_start_context and self.context is None:
+140 context_maybe = self.should_start_context(frame)
+141 if context_maybe is not None:
+142 self.context = context_maybe
+143 self.started_context = True
+144 self.switch_context(self.context)
+145 else:
+146 self.started_context = False
+147 else:
+148 self.started_context = False
+ +150 # Entering a new frame. Decide if we should trace
+151 # in this file.
+152 self._activity = True
+153 self.data_stack.append(
+154 (
+155 self.cur_file_dict,
+156 self.cur_file_name,
+157 self.last_line,
+158 self.started_context,
+159 )
+160 )
+161 filename = frame.f_code.co_filename
+162 self.cur_file_name = filename
+163 disp = self.should_trace_cache.get(filename)
+164 if disp is None:
+165 disp = self.should_trace(filename, frame)
+166 self.should_trace_cache[filename] = disp
+ +168 self.cur_file_dict = None
+169 if disp.trace:
+170 tracename = disp.source_filename
+171 if tracename not in self.data:
+172 self.data[tracename] = {}
+173 self.cur_file_dict = self.data[tracename]
+174 # The call event is really a "start frame" event, and happens for
+175 # function calls and re-entering generators. The f_lasti field is
+176 # -1 for calls, and a real offset for generators. Use <0 as the
+177 # line number for calls, and the real line number for generators.
+178 if getattr(frame, 'f_lasti', -1) < 0:
+179 self.last_line = -frame.f_code.co_firstlineno
+180 else:
+181 self.last_line = frame.f_lineno
+182 elif event == 'line':
+183 # Record an executed line.
+184 if self.cur_file_dict is not None:
+185 lineno = frame.f_lineno
+ +187 if self.trace_arcs:
+188 self.cur_file_dict[(self.last_line, lineno)] = None
+189 else:
+190 self.cur_file_dict[lineno] = None
+191 self.last_line = lineno
+192 elif event == 'return':
+193 if self.trace_arcs and self.cur_file_dict:
+194 # Record an arc leaving the function, but beware that a
+195 # "return" event might just mean yielding from a generator.
+196 # Jython seems to have an empty co_code, so just assume return.
+197 code = frame.f_code.co_code
+198 if (not code) or code[frame.f_lasti] != YIELD_VALUE:
+199 first = frame.f_code.co_firstlineno
+200 self.cur_file_dict[(self.last_line, -first)] = None
+201 # Leaving this function, pop the filename stack.
+202 self.cur_file_dict, self.cur_file_name, self.last_line, self.started_context = (
+203 self.data_stack.pop()
+204 )
+205 # Leaving a context?
+206 if self.started_context:
+207 self.context = None
+208 self.switch_context(None)
+209 elif event == 'exception':
+210 self.last_exc_back = frame.f_back
+211 self.last_exc_firstlineno = frame.f_code.co_firstlineno
+212 return self._trace
+ +214 def start(self):
+215 """Start this Tracer.
+ +217 Return a Python function suitable for use with sys.settrace().
+ +219 """
+220 self.stopped = False
+221 if self.threading:
+222 if self.thread is None:
+223 self.thread = self.threading.currentThread()
+224 else:
+225 if self.thread.ident != self.threading.currentThread().ident:
+226 # Re-starting from a different thread!? Don't set the trace
+227 # function, but we are marked as running again, so maybe it
+228 # will be ok?
+229 #self.log("~", "starting on different threads")
+230 return self._trace
+ +232 sys.settrace(self._trace)
+233 return self._trace
+ +235 def stop(self):
+236 """Stop this Tracer."""
+237 # Get the active tracer callback before setting the stop flag to be
+238 # able to detect if the tracer was changed prior to stopping it.
+239 tf = sys.gettrace()
+ +241 # Set the stop flag. The actual call to sys.settrace(None) will happen
+242 # in the self._trace callback itself to make sure to call it from the
+243 # right thread.
+244 self.stopped = True
+ +246 if self.threading and self.thread.ident != self.threading.currentThread().ident:
+247 # Called on a different thread than started us: we can't unhook
+248 # ourselves, but we've set the flag that we should stop, so we
+249 # won't do any more tracing.
+250 #self.log("~", "stopping on different threads")
+251 return
+ +253 if self.warn:
+254 # PyPy clears the trace function before running atexit functions,
+255 # so don't warn if we are in atexit on PyPy and the trace function
+256 # has changed to None.
+257 dont_warn = (env.PYPY and env.PYPYVERSION >= (5, 4) and self.in_atexit and tf is None)
+258 if (not dont_warn) and tf != self._trace: # pylint: disable=comparison-with-callable
+259 self.warn(
+260 "Trace function changed, measurement is likely wrong: %r" % (tf,),
+261 slug="trace-changed",
+262 )
+ +264 def activity(self):
+265 """Has there been any activity?"""
+266 return self._activity
+ +268 def reset_activity(self):
+269 """Reset the activity() flag."""
+270 self._activity = False
+ +272 def get_stats(self):
+273 """Return a dictionary of statistics, or None."""
+274 return None
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Reporter foundation for coverage.py."""
+5import sys
+ +7from coverage import env
+8from coverage.files import prep_patterns, FnmatchMatcher
+9from coverage.misc import CoverageException, NoSource, NotPython, ensure_dir_for_file, file_be_gone
+ + +12def render_report(output_path, reporter, morfs):
+13 """Run a report generator, managing the output file.
+ +15 This function ensures the output file is ready to be written to. Then writes
+16 the report to it. Then closes the file and cleans up.
+ +18 """
+19 file_to_close = None
+20 delete_file = False
+ +22 if output_path == "-":
+23 outfile = sys.stdout
+24 else:
+25 # Ensure that the output directory is created; done here
+26 # because this report pre-opens the output file.
+27 # HTMLReport does this using the Report plumbing because
+28 # its task is more complex, being multiple files.
+29 ensure_dir_for_file(output_path)
+30 open_kwargs = {}
+31 if env.PY3:
+32 open_kwargs["encoding"] = "utf8"
+33 outfile = open(output_path, "w", **open_kwargs)
+34 file_to_close = outfile
+ +36 try:
+37 return reporter.report(morfs, outfile=outfile)
+38 except CoverageException:
+39 delete_file = True
+40 raise
+41 finally:
+42 if file_to_close:
+43 file_to_close.close()
+44 if delete_file:
+45 file_be_gone(output_path) # pragma: part covered (doesn't return)
+ + +48def get_analysis_to_report(coverage, morfs):
+49 """Get the files to report on.
+ +51 For each morf in `morfs`, if it should be reported on (based on the omit
+52 and include configuration options), yield a pair, the `FileReporter` and
+53 `Analysis` for the morf.
+ +55 """
+56 file_reporters = coverage._get_file_reporters(morfs)
+57 config = coverage.config
+ +59 if config.report_include:
+60 matcher = FnmatchMatcher(prep_patterns(config.report_include))
+61 file_reporters = [fr for fr in file_reporters if matcher.match(fr.filename)]
+ +63 if config.report_omit:
+64 matcher = FnmatchMatcher(prep_patterns(config.report_omit))
+65 file_reporters = [fr for fr in file_reporters if not matcher.match(fr.filename)]
+ +67 if not file_reporters:
+68 raise CoverageException("No data to report.")
+ +70 for fr in sorted(file_reporters):
+71 try:
+72 analysis = coverage._analyze(fr)
+73 except NoSource:
+74 if not config.ignore_errors:
+75 raise
+76 except NotPython:
+77 # Only report errors for .py files, and only if we didn't
+78 # explicitly suppress those errors.
+79 # NotPython is only raised by PythonFileReporter, which has a
+80 # should_be_python() method.
+81 if fr.should_be_python():
+82 if config.ignore_errors:
+83 msg = "Couldn't parse Python file '{}'".format(fr.filename)
+84 coverage._warn(msg, slug="couldnt-parse")
+85 else:
+86 raise
+87 else:
+88 yield (fr, analysis)
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Results of coverage measurement."""
+ +6import collections
+ +8from coverage.backward import iitems
+9from coverage.debug import SimpleReprMixin
+10from coverage.misc import contract, CoverageException, nice_pair
+ + +13class Analysis(object):
+14 """The results of analyzing a FileReporter."""
+ +16 def __init__(self, data, file_reporter, file_mapper):
+17 self.data = data
+18 self.file_reporter = file_reporter
+19 self.filename = file_mapper(self.file_reporter.filename)
+20 self.statements = self.file_reporter.lines()
+21 self.excluded = self.file_reporter.excluded_lines()
+ +23 # Identify missing statements.
+24 executed = self.data.lines(self.filename) or []
+25 executed = self.file_reporter.translate_lines(executed)
+26 self.executed = executed
+27 self.missing = self.statements - self.executed
+ +29 if self.data.has_arcs():
+30 self._arc_possibilities = sorted(self.file_reporter.arcs())
+31 self.exit_counts = self.file_reporter.exit_counts()
+32 self.no_branch = self.file_reporter.no_branch_lines()
+33 n_branches = self._total_branches()
+34 mba = self.missing_branch_arcs()
+35 n_partial_branches = sum(len(v) for k,v in iitems(mba) if k not in self.missing)
+36 n_missing_branches = sum(len(v) for k,v in iitems(mba))
+37 else:
+38 self._arc_possibilities = []
+39 self.exit_counts = {}
+40 self.no_branch = set()
+41 n_branches = n_partial_branches = n_missing_branches = 0
+ +43 self.numbers = Numbers(
+44 n_files=1,
+45 n_statements=len(self.statements),
+46 n_excluded=len(self.excluded),
+47 n_missing=len(self.missing),
+48 n_branches=n_branches,
+49 n_partial_branches=n_partial_branches,
+50 n_missing_branches=n_missing_branches,
+51 )
+ +53 def missing_formatted(self, branches=False):
+54 """The missing line numbers, formatted nicely.
+ +56 Returns a string like "1-2, 5-11, 13-14".
+ +58 If `branches` is true, includes the missing branch arcs also.
+ +60 """
+61 if branches and self.has_arcs():
+62 arcs = iitems(self.missing_branch_arcs())
+63 else:
+64 arcs = None
+ +66 return format_lines(self.statements, self.missing, arcs=arcs)
+ +68 def has_arcs(self):
+69 """Were arcs measured in this result?"""
+70 return self.data.has_arcs()
+ +72 @contract(returns='list(tuple(int, int))')
+73 def arc_possibilities(self):
+74 """Returns a sorted list of the arcs in the code."""
+75 return self._arc_possibilities
+ +77 @contract(returns='list(tuple(int, int))')
+78 def arcs_executed(self):
+79 """Returns a sorted list of the arcs actually executed in the code."""
+80 executed = self.data.arcs(self.filename) or []
+81 executed = self.file_reporter.translate_arcs(executed)
+82 return sorted(executed)
+ +84 @contract(returns='list(tuple(int, int))')
+85 def arcs_missing(self):
+86 """Returns a sorted list of the arcs in the code not executed."""
+87 possible = self.arc_possibilities()
+88 executed = self.arcs_executed()
+89 missing = (
+90 p for p in possible
+91 if p not in executed
+92 and p[0] not in self.no_branch
+93 )
+94 return sorted(missing)
+ +96 @contract(returns='list(tuple(int, int))')
+97 def arcs_unpredicted(self):
+98 """Returns a sorted list of the executed arcs missing from the code."""
+99 possible = self.arc_possibilities()
+100 executed = self.arcs_executed()
+101 # Exclude arcs here which connect a line to itself. They can occur
+102 # in executed data in some cases. This is where they can cause
+103 # trouble, and here is where it's the least burden to remove them.
+104 # Also, generators can somehow cause arcs from "enter" to "exit", so
+105 # make sure we have at least one positive value.
+106 unpredicted = (
+107 e for e in executed
+108 if e not in possible
+109 and e[0] != e[1]
+110 and (e[0] > 0 or e[1] > 0)
+111 )
+112 return sorted(unpredicted)
+ +114 def _branch_lines(self):
+115 """Returns a list of line numbers that have more than one exit."""
+116 return [l1 for l1,count in iitems(self.exit_counts) if count > 1]
+ +118 def _total_branches(self):
+119 """How many total branches are there?"""
+120 return sum(count for count in self.exit_counts.values() if count > 1)
+ +122 @contract(returns='dict(int: list(int))')
+123 def missing_branch_arcs(self):
+124 """Return arcs that weren't executed from branch lines.
+ +126 Returns {l1:[l2a,l2b,...], ...}
+ +128 """
+129 missing = self.arcs_missing()
+130 branch_lines = set(self._branch_lines())
+131 mba = collections.defaultdict(list)
+132 for l1, l2 in missing:
+133 if l1 in branch_lines:
+134 mba[l1].append(l2)
+135 return mba
+ +137 @contract(returns='dict(int: tuple(int, int))')
+138 def branch_stats(self):
+139 """Get stats about branches.
+ +141 Returns a dict mapping line numbers to a tuple:
+142 (total_exits, taken_exits).
+143 """
+ +145 missing_arcs = self.missing_branch_arcs()
+146 stats = {}
+147 for lnum in self._branch_lines():
+148 exits = self.exit_counts[lnum]
+149 missing = len(missing_arcs[lnum])
+150 stats[lnum] = (exits, exits - missing)
+151 return stats
+ + +154class Numbers(SimpleReprMixin):
+155 """The numerical results of measuring coverage.
+ +157 This holds the basic statistics from `Analysis`, and is used to roll
+158 up statistics across files.
+ +160 """
+161 # A global to determine the precision on coverage percentages, the number
+162 # of decimal places.
+163 _precision = 0
+164 _near0 = 1.0 # These will change when _precision is changed.
+165 _near100 = 99.0
+ +167 def __init__(self, n_files=0, n_statements=0, n_excluded=0, n_missing=0,
+168 n_branches=0, n_partial_branches=0, n_missing_branches=0
+169 ):
+170 self.n_files = n_files
+171 self.n_statements = n_statements
+172 self.n_excluded = n_excluded
+173 self.n_missing = n_missing
+174 self.n_branches = n_branches
+175 self.n_partial_branches = n_partial_branches
+176 self.n_missing_branches = n_missing_branches
+ +178 def init_args(self):
+179 """Return a list for __init__(*args) to recreate this object."""
+180 return [
+181 self.n_files, self.n_statements, self.n_excluded, self.n_missing,
+182 self.n_branches, self.n_partial_branches, self.n_missing_branches,
+183 ]
+ +185 @classmethod
+186 def set_precision(cls, precision):
+187 """Set the number of decimal places used to report percentages."""
+188 assert 0 <= precision < 10
+189 cls._precision = precision
+190 cls._near0 = 1.0 / 10**precision
+191 cls._near100 = 100.0 - cls._near0
+ +193 @property
+194 def n_executed(self):
+195 """Returns the number of executed statements."""
+196 return self.n_statements - self.n_missing
+ +198 @property
+199 def n_executed_branches(self):
+200 """Returns the number of executed branches."""
+201 return self.n_branches - self.n_missing_branches
+ +203 @property
+204 def pc_covered(self):
+205 """Returns a single percentage value for coverage."""
+206 if self.n_statements > 0:
+207 numerator, denominator = self.ratio_covered
+208 pc_cov = (100.0 * numerator) / denominator
+209 else:
+210 pc_cov = 100.0
+211 return pc_cov
+ +213 @property
+214 def pc_covered_str(self):
+215 """Returns the percent covered, as a string, without a percent sign.
+ +217 Note that "0" is only returned when the value is truly zero, and "100"
+218 is only returned when the value is truly 100. Rounding can never
+219 result in either "0" or "100".
+ +221 """
+222 pc = self.pc_covered
+223 if 0 < pc < self._near0:
+224 pc = self._near0
+225 elif self._near100 < pc < 100:
+226 pc = self._near100
+227 else:
+228 pc = round(pc, self._precision)
+229 return "%.*f" % (self._precision, pc)
+ +231 @classmethod
+232 def pc_str_width(cls):
+233 """How many characters wide can pc_covered_str be?"""
+234 width = 3 # "100"
+235 if cls._precision > 0:
+236 width += 1 + cls._precision
+237 return width
+ +239 @property
+240 def ratio_covered(self):
+241 """Return a numerator and denominator for the coverage ratio."""
+242 numerator = self.n_executed + self.n_executed_branches
+243 denominator = self.n_statements + self.n_branches
+244 return numerator, denominator
+ +246 def __add__(self, other):
+247 nums = Numbers()
+248 nums.n_files = self.n_files + other.n_files
+249 nums.n_statements = self.n_statements + other.n_statements
+250 nums.n_excluded = self.n_excluded + other.n_excluded
+251 nums.n_missing = self.n_missing + other.n_missing
+252 nums.n_branches = self.n_branches + other.n_branches
+253 nums.n_partial_branches = (
+254 self.n_partial_branches + other.n_partial_branches
+255 )
+256 nums.n_missing_branches = (
+257 self.n_missing_branches + other.n_missing_branches
+258 )
+259 return nums
+ +261 def __radd__(self, other):
+262 # Implementing 0+Numbers allows us to sum() a list of Numbers.
+263 if other == 0:
+264 return self
+265 return NotImplemented # pragma: not covered (we never call it this way)
+ + +268def _line_ranges(statements, lines):
+269 """Produce a list of ranges for `format_lines`."""
+270 statements = sorted(statements)
+271 lines = sorted(lines)
+ +273 pairs = []
+274 start = None
+275 lidx = 0
+276 for stmt in statements:
+277 if lidx >= len(lines):
+278 break
+279 if stmt == lines[lidx]:
+280 lidx += 1
+281 if not start:
+282 start = stmt
+283 end = stmt
+284 elif start:
+285 pairs.append((start, end))
+286 start = None
+287 if start:
+288 pairs.append((start, end))
+289 return pairs
+ + +292def format_lines(statements, lines, arcs=None):
+293 """Nicely format a list of line numbers.
+ +295 Format a list of line numbers for printing by coalescing groups of lines as
+296 long as the lines represent consecutive statements. This will coalesce
+297 even if there are gaps between statements.
+ +299 For example, if `statements` is [1,2,3,4,5,10,11,12,13,14] and
+300 `lines` is [1,2,5,10,11,13,14] then the result will be "1-2, 5-11, 13-14".
+ +302 Both `lines` and `statements` can be any iterable. All of the elements of
+303 `lines` must be in `statements`, and all of the values must be positive
+304 integers.
+ +306 If `arcs` is provided, they are (start,[end,end,end]) pairs that will be
+307 included in the output as long as start isn't in `lines`.
+ +309 """
+310 line_items = [(pair[0], nice_pair(pair)) for pair in _line_ranges(statements, lines)]
+311 if arcs:
+312 line_exits = sorted(arcs)
+313 for line, exits in line_exits:
+314 for ex in sorted(exits):
+315 if line not in lines and ex not in lines:
+316 dest = (ex if ex > 0 else "exit")
+317 line_items.append((line, "%d->%s" % (line, dest)))
+ +319 ret = ', '.join(t[-1] for t in sorted(line_items))
+320 return ret
+ + +323@contract(total='number', fail_under='number', precision=int, returns=bool)
+324def should_fail_under(total, fail_under, precision):
+325 """Determine if a total should fail due to fail-under.
+ +327 `total` is a float, the coverage measurement total. `fail_under` is the
+328 fail_under setting to compare with. `precision` is the number of digits
+329 to consider after the decimal point.
+ +331 Returns True if the total should fail.
+ +333 """
+334 # We can never achieve higher than 100% coverage, or less than zero.
+335 if not (0 <= fail_under <= 100.0):
+336 msg = "fail_under={} is invalid. Must be between 0 and 100.".format(fail_under)
+337 raise CoverageException(msg)
+ +339 # Special case for fail_under=100, it must really be 100.
+340 if fail_under == 100.0 and total != 100.0:
+341 return True
+ +343 return round(total, precision) < fail_under
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Sqlite coverage data."""
+ +6# TODO: factor out dataop debugging to a wrapper class?
+7# TODO: make sure all dataop debugging is in place somehow
+ +9import collections
+10import datetime
+11import glob
+12import itertools
+13import os
+14import re
+15import sqlite3
+16import sys
+17import zlib
+ +19from coverage import env
+20from coverage.backward import get_thread_id, iitems, to_bytes, to_string
+21from coverage.debug import NoDebugging, SimpleReprMixin, clipped_repr
+22from coverage.files import PathAliases
+23from coverage.misc import CoverageException, contract, file_be_gone, filename_suffix, isolate_module
+24from coverage.numbits import numbits_to_nums, numbits_union, nums_to_numbits
+25from coverage.version import __version__
+ +27os = isolate_module(os)
+ +29# If you change the schema, increment the SCHEMA_VERSION, and update the
+30# docs in docs/dbschema.rst also.
+ +32SCHEMA_VERSION = 7
+ +34# Schema versions:
+35# 1: Released in 5.0a2
+36# 2: Added contexts in 5.0a3.
+37# 3: Replaced line table with line_map table.
+38# 4: Changed line_map.bitmap to line_map.numbits.
+39# 5: Added foreign key declarations.
+40# 6: Key-value in meta.
+41# 7: line_map -> line_bits
+ +43SCHEMA = """\
+44CREATE TABLE coverage_schema (
+45 -- One row, to record the version of the schema in this db.
+46 version integer
+47);
+ +49CREATE TABLE meta (
+50 -- Key-value pairs, to record metadata about the data
+51 key text,
+52 value text,
+53 unique (key)
+54 -- Keys:
+55 -- 'has_arcs' boolean -- Is this data recording branches?
+56 -- 'sys_argv' text -- The coverage command line that recorded the data.
+57 -- 'version' text -- The version of coverage.py that made the file.
+58 -- 'when' text -- Datetime when the file was created.
+59);
+ +61CREATE TABLE file (
+62 -- A row per file measured.
+63 id integer primary key,
+64 path text,
+65 unique (path)
+66);
+ +68CREATE TABLE context (
+69 -- A row per context measured.
+70 id integer primary key,
+71 context text,
+72 unique (context)
+73);
+ +75CREATE TABLE line_bits (
+76 -- If recording lines, a row per context per file executed.
+77 -- All of the line numbers for that file/context are in one numbits.
+78 file_id integer, -- foreign key to `file`.
+79 context_id integer, -- foreign key to `context`.
+80 numbits blob, -- see the numbits functions in coverage.numbits
+81 foreign key (file_id) references file (id),
+82 foreign key (context_id) references context (id),
+83 unique (file_id, context_id)
+84);
+ +86CREATE TABLE arc (
+87 -- If recording branches, a row per context per from/to line transition executed.
+88 file_id integer, -- foreign key to `file`.
+89 context_id integer, -- foreign key to `context`.
+90 fromno integer, -- line number jumped from.
+91 tono integer, -- line number jumped to.
+92 foreign key (file_id) references file (id),
+93 foreign key (context_id) references context (id),
+94 unique (file_id, context_id, fromno, tono)
+95);
+ +97CREATE TABLE tracer (
+98 -- A row per file indicating the tracer used for that file.
+99 file_id integer primary key,
+100 tracer text,
+101 foreign key (file_id) references file (id)
+102);
+103"""
+ +105class CoverageData(SimpleReprMixin):
+106 """Manages collected coverage data, including file storage.
+ +108 This class is the public supported API to the data that coverage.py
+109 collects during program execution. It includes information about what code
+110 was executed. It does not include information from the analysis phase, to
+111 determine what lines could have been executed, or what lines were not
+112 executed.
+ +114 .. note::
+ +116 The data file is currently a SQLite database file, with a
+117 :ref:`documented schema <dbschema>`. The schema is subject to change
+118 though, so be careful about querying it directly. Use this API if you
+119 can to isolate yourself from changes.
+ +121 There are a number of kinds of data that can be collected:
+ +123 * **lines**: the line numbers of source lines that were executed.
+124 These are always available.
+ +126 * **arcs**: pairs of source and destination line numbers for transitions
+127 between source lines. These are only available if branch coverage was
+128 used.
+ +130 * **file tracer names**: the module names of the file tracer plugins that
+131 handled each file in the data.
+ +133 Lines, arcs, and file tracer names are stored for each source file. File
+134 names in this API are case-sensitive, even on platforms with
+135 case-insensitive file systems.
+ +137 A data file either stores lines, or arcs, but not both.
+ +139 A data file is associated with the data when the :class:`CoverageData`
+140 is created, using the parameters `basename`, `suffix`, and `no_disk`. The
+141 base name can be queried with :meth:`base_filename`, and the actual file
+142 name being used is available from :meth:`data_filename`.
+ +144 To read an existing coverage.py data file, use :meth:`read`. You can then
+145 access the line, arc, or file tracer data with :meth:`lines`, :meth:`arcs`,
+146 or :meth:`file_tracer`.
+ +148 The :meth:`has_arcs` method indicates whether arc data is available. You
+149 can get a set of the files in the data with :meth:`measured_files`. As
+150 with most Python containers, you can determine if there is any data at all
+151 by using this object as a boolean value.
+ +153 The contexts for each line in a file can be read with
+154 :meth:`contexts_by_lineno`.
+ +156 To limit querying to certain contexts, use :meth:`set_query_context` or
+157 :meth:`set_query_contexts`. These will narrow the focus of subsequent
+158 :meth:`lines`, :meth:`arcs`, and :meth:`contexts_by_lineno` calls. The set
+159 of all measured context names can be retrieved with
+160 :meth:`measured_contexts`.
+ +162 Most data files will be created by coverage.py itself, but you can use
+163 methods here to create data files if you like. The :meth:`add_lines`,
+164 :meth:`add_arcs`, and :meth:`add_file_tracers` methods add data, in ways
+165 that are convenient for coverage.py.
+ +167 To record data for contexts, use :meth:`set_context` to set a context to
+168 be used for subsequent :meth:`add_lines` and :meth:`add_arcs` calls.
+ +170 To add a source file without any measured data, use :meth:`touch_file`,
+171 or :meth:`touch_files` for a list of such files.
+ +173 Write the data to its file with :meth:`write`.
+ +175 You can clear the data in memory with :meth:`erase`. Two data collections
+176 can be combined by using :meth:`update` on one :class:`CoverageData`,
+177 passing it the other.
+ +179 Data in a :class:`CoverageData` can be serialized and deserialized with
+180 :meth:`dumps` and :meth:`loads`.
+ +182 """
+ +184 def __init__(self, basename=None, suffix=None, no_disk=False, warn=None, debug=None):
+185 """Create a :class:`CoverageData` object to hold coverage-measured data.
+ +187 Arguments:
+188 basename (str): the base name of the data file, defaulting to
+189 ".coverage".
+190 suffix (str or bool): has the same meaning as the `data_suffix`
+191 argument to :class:`coverage.Coverage`.
+192 no_disk (bool): if True, keep all data in memory, and don't
+193 write any disk file.
+194 warn: a warning callback function, accepting a warning message
+195 argument.
+196 debug: a `DebugControl` object (optional)
+ +198 """
+199 self._no_disk = no_disk
+200 self._basename = os.path.abspath(basename or ".coverage")
+201 self._suffix = suffix
+202 self._warn = warn
+203 self._debug = debug or NoDebugging()
+ +205 self._choose_filename()
+206 self._file_map = {}
+207 # Maps thread ids to SqliteDb objects.
+208 self._dbs = {}
+209 self._pid = os.getpid()
+ +211 # Are we in sync with the data file?
+212 self._have_used = False
+ +214 self._has_lines = False
+215 self._has_arcs = False
+ +217 self._current_context = None
+218 self._current_context_id = None
+219 self._query_context_ids = None
+ +221 def _choose_filename(self):
+222 """Set self._filename based on inited attributes."""
+223 if self._no_disk:
+224 self._filename = ":memory:"
+225 else:
+226 self._filename = self._basename
+227 suffix = filename_suffix(self._suffix)
+228 if suffix:
+229 self._filename += "." + suffix
+ +231 def _reset(self):
+232 """Reset our attributes."""
+233 if self._dbs:
+234 for db in self._dbs.values():
+235 db.close()
+236 self._dbs = {}
+237 self._file_map = {}
+238 self._have_used = False
+239 self._current_context_id = None
+ +241 def _create_db(self):
+242 """Create a db file that doesn't exist yet.
+ +244 Initializes the schema and certain metadata.
+245 """
+246 if self._debug.should('dataio'):
+247 self._debug.write("Creating data file {!r}".format(self._filename))
+248 self._dbs[get_thread_id()] = db = SqliteDb(self._filename, self._debug)
+249 with db:
+250 db.executescript(SCHEMA)
+251 db.execute("insert into coverage_schema (version) values (?)", (SCHEMA_VERSION,))
+252 db.executemany(
+253 "insert into meta (key, value) values (?, ?)",
+254 [
+255 ('sys_argv', str(getattr(sys, 'argv', None))),
+256 ('version', __version__),
+257 ('when', datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')),
+258 ]
+259 )
+ +261 def _open_db(self):
+262 """Open an existing db file, and read its metadata."""
+263 if self._debug.should('dataio'):
+264 self._debug.write("Opening data file {!r}".format(self._filename))
+265 self._dbs[get_thread_id()] = SqliteDb(self._filename, self._debug)
+266 self._read_db()
+ +268 def _read_db(self):
+269 """Read the metadata from a database so that we are ready to use it."""
+270 with self._dbs[get_thread_id()] as db:
+271 try:
+272 schema_version, = db.execute_one("select version from coverage_schema")
+273 except Exception as exc:
+274 raise CoverageException(
+275 "Data file {!r} doesn't seem to be a coverage data file: {}".format(
+276 self._filename, exc
+277 )
+278 )
+279 else:
+280 if schema_version != SCHEMA_VERSION:
+281 raise CoverageException(
+282 "Couldn't use data file {!r}: wrong schema: {} instead of {}".format(
+283 self._filename, schema_version, SCHEMA_VERSION
+284 )
+285 )
+ +287 for row in db.execute("select value from meta where key = 'has_arcs'"):
+288 self._has_arcs = bool(int(row[0]))
+289 self._has_lines = not self._has_arcs
+ +291 for path, file_id in db.execute("select path, id from file"):
+292 self._file_map[path] = file_id
+ +294 def _connect(self):
+295 """Get the SqliteDb object to use."""
+296 if get_thread_id() not in self._dbs:
+297 if os.path.exists(self._filename):
+298 self._open_db()
+299 else:
+300 self._create_db()
+301 return self._dbs[get_thread_id()]
+ +303 def __nonzero__(self):
+304 if (get_thread_id() not in self._dbs and not os.path.exists(self._filename)):
+305 return False
+306 try:
+307 with self._connect() as con:
+308 rows = con.execute("select * from file limit 1")
+309 return bool(list(rows))
+310 except CoverageException:
+311 return False
+ +313 __bool__ = __nonzero__
+ +315 @contract(returns='bytes')
+316 def dumps(self):
+317 """Serialize the current data to a byte string.
+ +319 The format of the serialized data is not documented. It is only
+320 suitable for use with :meth:`loads` in the same version of
+321 coverage.py.
+ +323 Returns:
+324 A byte string of serialized data.
+ +326 .. versionadded:: 5.0
+ +328 """
+329 if self._debug.should('dataio'): 329 ↛ 330line 329 didn't jump to line 330, because the condition on line 329 was never true
+330 self._debug.write("Dumping data from data file {!r}".format(self._filename))
+331 with self._connect() as con:
+332 return b'z' + zlib.compress(to_bytes(con.dump()))
+ +334 @contract(data='bytes')
+335 def loads(self, data):
+336 """Deserialize data from :meth:`dumps`
+ +338 Use with a newly-created empty :class:`CoverageData` object. It's
+339 undefined what happens if the object already has data in it.
+ +341 Arguments:
+342 data: A byte string of serialized data produced by :meth:`dumps`.
+ +344 .. versionadded:: 5.0
+ +346 """
+347 if self._debug.should('dataio'): 347 ↛ 348line 347 didn't jump to line 348, because the condition on line 347 was never true
+348 self._debug.write("Loading data into data file {!r}".format(self._filename))
+349 if data[:1] != b'z':
+350 raise CoverageException(
+351 "Unrecognized serialization: {!r} (head of {} bytes)".format(data[:40], len(data))
+352 )
+353 script = to_string(zlib.decompress(data[1:]))
+354 self._dbs[get_thread_id()] = db = SqliteDb(self._filename, self._debug)
+355 with db:
+356 db.executescript(script)
+357 self._read_db()
+358 self._have_used = True
+ +360 def _file_id(self, filename, add=False):
+361 """Get the file id for `filename`.
+ +363 If filename is not in the database yet, add it if `add` is True.
+364 If `add` is not True, return None.
+365 """
+366 if filename not in self._file_map:
+367 if add:
+368 with self._connect() as con:
+369 cur = con.execute("insert or replace into file (path) values (?)", (filename,))
+370 self._file_map[filename] = cur.lastrowid
+371 return self._file_map.get(filename)
+ +373 def _context_id(self, context):
+374 """Get the id for a context."""
+375 assert context is not None
+376 self._start_using()
+377 with self._connect() as con:
+378 row = con.execute_one("select id from context where context = ?", (context,))
+379 if row is not None:
+380 return row[0]
+381 else:
+382 return None
+ +384 def set_context(self, context):
+385 """Set the current context for future :meth:`add_lines` etc.
+ +387 `context` is a str, the name of the context to use for the next data
+388 additions. The context persists until the next :meth:`set_context`.
+ +390 .. versionadded:: 5.0
+ +392 """
+393 if self._debug.should('dataop'):
+394 self._debug.write("Setting context: %r" % (context,))
+395 self._current_context = context
+396 self._current_context_id = None
+ +398 def _set_context_id(self):
+399 """Use the _current_context to set _current_context_id."""
+400 context = self._current_context or ""
+401 context_id = self._context_id(context)
+402 if context_id is not None:
+403 self._current_context_id = context_id
+404 else:
+405 with self._connect() as con:
+406 cur = con.execute("insert into context (context) values (?)", (context,))
+407 self._current_context_id = cur.lastrowid
+ +409 def base_filename(self):
+410 """The base filename for storing data.
+ +412 .. versionadded:: 5.0
+ +414 """
+415 return self._basename
+ +417 def data_filename(self):
+418 """Where is the data stored?
+ +420 .. versionadded:: 5.0
+ +422 """
+423 return self._filename
+ +425 def add_lines(self, line_data):
+426 """Add measured line data.
+ +428 `line_data` is a dictionary mapping file names to dictionaries::
+ +430 { filename: { lineno: None, ... }, ...}
+ +432 """
+433 if self._debug.should('dataop'):
+434 self._debug.write("Adding lines: %d files, %d lines total" % (
+435 len(line_data), sum(len(lines) for lines in line_data.values())
+436 ))
+437 self._start_using()
+438 self._choose_lines_or_arcs(lines=True)
+439 if not line_data:
+440 return
+441 with self._connect() as con:
+442 self._set_context_id()
+443 for filename, linenos in iitems(line_data):
+444 linemap = nums_to_numbits(linenos)
+445 file_id = self._file_id(filename, add=True)
+446 query = "select numbits from line_bits where file_id = ? and context_id = ?"
+447 existing = list(con.execute(query, (file_id, self._current_context_id)))
+448 if existing:
+449 linemap = numbits_union(linemap, existing[0][0])
+ +451 con.execute(
+452 "insert or replace into line_bits "
+453 " (file_id, context_id, numbits) values (?, ?, ?)",
+454 (file_id, self._current_context_id, linemap),
+455 )
+ +457 def add_arcs(self, arc_data):
+458 """Add measured arc data.
+ +460 `arc_data` is a dictionary mapping file names to dictionaries::
+ +462 { filename: { (l1,l2): None, ... }, ...}
+ +464 """
+465 if self._debug.should('dataop'): 465 ↛ 466line 465 didn't jump to line 466, because the condition on line 465 was never true
+466 self._debug.write("Adding arcs: %d files, %d arcs total" % (
+467 len(arc_data), sum(len(arcs) for arcs in arc_data.values())
+468 ))
+469 self._start_using()
+470 self._choose_lines_or_arcs(arcs=True)
+471 if not arc_data:
+472 return
+473 with self._connect() as con:
+474 self._set_context_id()
+475 for filename, arcs in iitems(arc_data):
+476 file_id = self._file_id(filename, add=True)
+477 data = [(file_id, self._current_context_id, fromno, tono) for fromno, tono in arcs]
+478 con.executemany(
+479 "insert or ignore into arc "
+480 "(file_id, context_id, fromno, tono) values (?, ?, ?, ?)",
+481 data,
+482 )
+ +484 def _choose_lines_or_arcs(self, lines=False, arcs=False):
+485 """Force the data file to choose between lines and arcs."""
+486 assert lines or arcs
+487 assert not (lines and arcs)
+488 if lines and self._has_arcs:
+489 raise CoverageException("Can't add line measurements to existing branch data")
+490 if arcs and self._has_lines:
+491 raise CoverageException("Can't add branch measurements to existing line data")
+492 if not self._has_arcs and not self._has_lines:
+493 self._has_lines = lines
+494 self._has_arcs = arcs
+495 with self._connect() as con:
+496 con.execute(
+497 "insert into meta (key, value) values (?, ?)",
+498 ('has_arcs', str(int(arcs)))
+499 )
+ +501 def add_file_tracers(self, file_tracers):
+502 """Add per-file plugin information.
+ +504 `file_tracers` is { filename: plugin_name, ... }
+ +506 """
+507 if self._debug.should('dataop'):
+508 self._debug.write("Adding file tracers: %d files" % (len(file_tracers),))
+509 if not file_tracers:
+510 return
+511 self._start_using()
+512 with self._connect() as con:
+513 for filename, plugin_name in iitems(file_tracers):
+514 file_id = self._file_id(filename)
+515 if file_id is None:
+516 raise CoverageException(
+517 "Can't add file tracer data for unmeasured file '%s'" % (filename,)
+518 )
+ +520 existing_plugin = self.file_tracer(filename)
+521 if existing_plugin:
+522 if existing_plugin != plugin_name: 522 ↛ 513line 522 didn't jump to line 513, because the condition on line 522 was never false
+523 raise CoverageException(
+524 "Conflicting file tracer name for '%s': %r vs %r" % (
+525 filename, existing_plugin, plugin_name,
+526 )
+527 )
+528 elif plugin_name: 528 ↛ 513line 528 didn't jump to line 513, because the condition on line 528 was never false
+529 con.execute(
+530 "insert into tracer (file_id, tracer) values (?, ?)",
+531 (file_id, plugin_name)
+532 )
+ +534 def touch_file(self, filename, plugin_name=""):
+535 """Ensure that `filename` appears in the data, empty if needed.
+ +537 `plugin_name` is the name of the plugin responsible for this file. It is used
+538 to associate the right filereporter, etc.
+539 """
+540 self.touch_files([filename], plugin_name)
+ +542 def touch_files(self, filenames, plugin_name=""):
+543 """Ensure that `filenames` appear in the data, empty if needed.
+ +545 `plugin_name` is the name of the plugin responsible for these files. It is used
+546 to associate the right filereporter, etc.
+547 """
+548 if self._debug.should('dataop'): 548 ↛ 549line 548 didn't jump to line 549, because the condition on line 548 was never true
+549 self._debug.write("Touching %r" % (filenames,))
+550 self._start_using()
+551 with self._connect(): # Use this to get one transaction.
+552 if not self._has_arcs and not self._has_lines: 552 ↛ 553line 552 didn't jump to line 553, because the condition on line 552 was never true
+553 raise CoverageException("Can't touch files in an empty CoverageData")
+ +555 for filename in filenames:
+556 self._file_id(filename, add=True)
+557 if plugin_name:
+558 # Set the tracer for this file
+559 self.add_file_tracers({filename: plugin_name})
+ +561 def update(self, other_data, aliases=None):
+562 """Update this data with data from several other :class:`CoverageData` instances.
+ +564 If `aliases` is provided, it's a `PathAliases` object that is used to
+565 re-map paths to match the local machine's.
+566 """
+567 if self._debug.should('dataop'): 567 ↛ 568line 567 didn't jump to line 568, because the condition on line 567 was never true
+568 self._debug.write("Updating with data from %r" % (
+569 getattr(other_data, '_filename', '???'),
+570 ))
+571 if self._has_lines and other_data._has_arcs:
+572 raise CoverageException("Can't combine arc data with line data")
+573 if self._has_arcs and other_data._has_lines:
+574 raise CoverageException("Can't combine line data with arc data")
+ +576 aliases = aliases or PathAliases()
+ +578 # Force the database we're writing to to exist before we start nesting
+579 # contexts.
+580 self._start_using()
+ +582 # Collector for all arcs, lines and tracers
+583 other_data.read()
+584 with other_data._connect() as conn:
+585 # Get files data.
+586 cur = conn.execute('select path from file')
+587 files = {path: aliases.map(path) for (path,) in cur}
+588 cur.close()
+ +590 # Get contexts data.
+591 cur = conn.execute('select context from context')
+592 contexts = [context for (context,) in cur]
+593 cur.close()
+ +595 # Get arc data.
+596 cur = conn.execute(
+597 'select file.path, context.context, arc.fromno, arc.tono '
+598 'from arc '
+599 'inner join file on file.id = arc.file_id '
+600 'inner join context on context.id = arc.context_id'
+601 )
+602 arcs = [(files[path], context, fromno, tono) for (path, context, fromno, tono) in cur]
+603 cur.close()
+ +605 # Get line data.
+606 cur = conn.execute(
+607 'select file.path, context.context, line_bits.numbits '
+608 'from line_bits '
+609 'inner join file on file.id = line_bits.file_id '
+610 'inner join context on context.id = line_bits.context_id'
+611 )
+612 lines = {
+613 (files[path], context): numbits
+614 for (path, context, numbits) in cur
+615 }
+616 cur.close()
+ +618 # Get tracer data.
+619 cur = conn.execute(
+620 'select file.path, tracer '
+621 'from tracer '
+622 'inner join file on file.id = tracer.file_id'
+623 )
+624 tracers = {files[path]: tracer for (path, tracer) in cur}
+625 cur.close()
+ +627 with self._connect() as conn:
+628 conn.con.isolation_level = 'IMMEDIATE'
+ +630 # Get all tracers in the DB. Files not in the tracers are assumed
+631 # to have an empty string tracer. Since Sqlite does not support
+632 # full outer joins, we have to make two queries to fill the
+633 # dictionary.
+634 this_tracers = {path: '' for path, in conn.execute('select path from file')}
+635 this_tracers.update({
+636 aliases.map(path): tracer
+637 for path, tracer in conn.execute(
+638 'select file.path, tracer from tracer '
+639 'inner join file on file.id = tracer.file_id'
+640 )
+641 })
+ +643 # Create all file and context rows in the DB.
+644 conn.executemany(
+645 'insert or ignore into file (path) values (?)',
+646 ((file,) for file in files.values())
+647 )
+648 file_ids = {
+649 path: id
+650 for id, path in conn.execute('select id, path from file')
+651 }
+652 conn.executemany(
+653 'insert or ignore into context (context) values (?)',
+654 ((context,) for context in contexts)
+655 )
+656 context_ids = {
+657 context: id
+658 for id, context in conn.execute('select id, context from context')
+659 }
+ +661 # Prepare tracers and fail, if a conflict is found.
+662 # tracer_paths is used to ensure consistency over the tracer data
+663 # and tracer_map tracks the tracers to be inserted.
+664 tracer_map = {}
+665 for path in files.values():
+666 this_tracer = this_tracers.get(path)
+667 other_tracer = tracers.get(path, '')
+668 # If there is no tracer, there is always the None tracer.
+669 if this_tracer is not None and this_tracer != other_tracer:
+670 raise CoverageException(
+671 "Conflicting file tracer name for '%s': %r vs %r" % (
+672 path, this_tracer, other_tracer
+673 )
+674 )
+675 tracer_map[path] = other_tracer
+ +677 # Prepare arc and line rows to be inserted by converting the file
+678 # and context strings with integer ids. Then use the efficient
+679 # `executemany()` to insert all rows at once.
+680 arc_rows = (
+681 (file_ids[file], context_ids[context], fromno, tono)
+682 for file, context, fromno, tono in arcs
+683 )
+ +685 # Get line data.
+686 cur = conn.execute(
+687 'select file.path, context.context, line_bits.numbits '
+688 'from line_bits '
+689 'inner join file on file.id = line_bits.file_id '
+690 'inner join context on context.id = line_bits.context_id'
+691 )
+692 for path, context, numbits in cur:
+693 key = (aliases.map(path), context)
+694 if key in lines:
+695 numbits = numbits_union(lines[key], numbits)
+696 lines[key] = numbits
+697 cur.close()
+ +699 if arcs:
+700 self._choose_lines_or_arcs(arcs=True)
+ +702 # Write the combined data.
+703 conn.executemany(
+704 'insert or ignore into arc '
+705 '(file_id, context_id, fromno, tono) values (?, ?, ?, ?)',
+706 arc_rows
+707 )
+ +709 if lines:
+710 self._choose_lines_or_arcs(lines=True)
+711 conn.execute("delete from line_bits")
+712 conn.executemany(
+713 "insert into line_bits "
+714 "(file_id, context_id, numbits) values (?, ?, ?)",
+715 [
+716 (file_ids[file], context_ids[context], numbits)
+717 for (file, context), numbits in lines.items()
+718 ]
+719 )
+720 conn.executemany(
+721 'insert or ignore into tracer (file_id, tracer) values (?, ?)',
+722 ((file_ids[filename], tracer) for filename, tracer in tracer_map.items())
+723 )
+ +725 # Update all internal cache data.
+726 self._reset()
+727 self.read()
+ +729 def erase(self, parallel=False):
+730 """Erase the data in this object.
+ +732 If `parallel` is true, then also deletes data files created from the
+733 basename by parallel-mode.
+ +735 """
+736 self._reset()
+737 if self._no_disk:
+738 return
+739 if self._debug.should('dataio'):
+740 self._debug.write("Erasing data file {!r}".format(self._filename))
+741 file_be_gone(self._filename)
+742 if parallel:
+743 data_dir, local = os.path.split(self._filename)
+744 localdot = local + '.*'
+745 pattern = os.path.join(os.path.abspath(data_dir), localdot)
+746 for filename in glob.glob(pattern):
+747 if self._debug.should('dataio'): 747 ↛ 748line 747 didn't jump to line 748, because the condition on line 747 was never true
+748 self._debug.write("Erasing parallel data file {!r}".format(filename))
+749 file_be_gone(filename)
+ +751 def read(self):
+752 """Start using an existing data file."""
+753 with self._connect(): # TODO: doesn't look right
+754 self._have_used = True
+ +756 def write(self):
+757 """Ensure the data is written to the data file."""
+758 pass
+ +760 def _start_using(self):
+761 """Call this before using the database at all."""
+762 if self._pid != os.getpid():
+763 # Looks like we forked! Have to start a new data file.
+764 self._reset()
+765 self._choose_filename()
+766 self._pid = os.getpid()
+767 if not self._have_used:
+768 self.erase()
+769 self._have_used = True
+ +771 def has_arcs(self):
+772 """Does the database have arcs (True) or lines (False)."""
+773 return bool(self._has_arcs)
+ +775 def measured_files(self):
+776 """A set of all files that had been measured."""
+777 return set(self._file_map)
+ +779 def measured_contexts(self):
+780 """A set of all contexts that have been measured.
+ +782 .. versionadded:: 5.0
+ +784 """
+785 self._start_using()
+786 with self._connect() as con:
+787 contexts = {row[0] for row in con.execute("select distinct(context) from context")}
+788 return contexts
+ +790 def file_tracer(self, filename):
+791 """Get the plugin name of the file tracer for a file.
+ +793 Returns the name of the plugin that handles this file. If the file was
+794 measured, but didn't use a plugin, then "" is returned. If the file
+795 was not measured, then None is returned.
+ +797 """
+798 self._start_using()
+799 with self._connect() as con:
+800 file_id = self._file_id(filename)
+801 if file_id is None:
+802 return None
+803 row = con.execute_one("select tracer from tracer where file_id = ?", (file_id,))
+804 if row is not None:
+805 return row[0] or ""
+806 return "" # File was measured, but no tracer associated.
+ +808 def set_query_context(self, context):
+809 """Set a context for subsequent querying.
+ +811 The next :meth:`lines`, :meth:`arcs`, or :meth:`contexts_by_lineno`
+812 calls will be limited to only one context. `context` is a string which
+813 must match a context exactly. If it does not, no exception is raised,
+814 but queries will return no data.
+ +816 .. versionadded:: 5.0
+ +818 """
+819 self._start_using()
+820 with self._connect() as con:
+821 cur = con.execute("select id from context where context = ?", (context,))
+822 self._query_context_ids = [row[0] for row in cur.fetchall()]
+ +824 def set_query_contexts(self, contexts):
+825 """Set a number of contexts for subsequent querying.
+ +827 The next :meth:`lines`, :meth:`arcs`, or :meth:`contexts_by_lineno`
+828 calls will be limited to the specified contexts. `contexts` is a list
+829 of Python regular expressions. Contexts will be matched using
+830 :func:`re.search <python:re.search>`. Data will be included in query
+831 results if they are part of any of the contexts matched.
+ +833 .. versionadded:: 5.0
+ +835 """
+836 self._start_using()
+837 if contexts:
+838 with self._connect() as con:
+839 context_clause = ' or '.join(['context regexp ?'] * len(contexts))
+840 cur = con.execute("select id from context where " + context_clause, contexts)
+841 self._query_context_ids = [row[0] for row in cur.fetchall()]
+842 else:
+843 self._query_context_ids = None
+ +845 def lines(self, filename):
+846 """Get the list of lines executed for a file.
+ +848 If the file was not measured, returns None. A file might be measured,
+849 and have no lines executed, in which case an empty list is returned.
+ +851 If the file was executed, returns a list of integers, the line numbers
+852 executed in the file. The list is in no particular order.
+ +854 """
+855 self._start_using()
+856 if self.has_arcs():
+857 arcs = self.arcs(filename)
+858 if arcs is not None:
+859 all_lines = itertools.chain.from_iterable(arcs)
+860 return list({l for l in all_lines if l > 0})
+ +862 with self._connect() as con:
+863 file_id = self._file_id(filename)
+864 if file_id is None:
+865 return None
+866 else:
+867 query = "select numbits from line_bits where file_id = ?"
+868 data = [file_id]
+869 if self._query_context_ids is not None:
+870 ids_array = ', '.join('?' * len(self._query_context_ids))
+871 query += " and context_id in (" + ids_array + ")"
+872 data += self._query_context_ids
+873 bitmaps = list(con.execute(query, data))
+874 nums = set()
+875 for row in bitmaps:
+876 nums.update(numbits_to_nums(row[0]))
+877 return list(nums)
+ +879 def arcs(self, filename):
+880 """Get the list of arcs executed for a file.
+ +882 If the file was not measured, returns None. A file might be measured,
+883 and have no arcs executed, in which case an empty list is returned.
+ +885 If the file was executed, returns a list of 2-tuples of integers. Each
+886 pair is a starting line number and an ending line number for a
+887 transition from one line to another. The list is in no particular
+888 order.
+ +890 Negative numbers have special meaning. If the starting line number is
+891 -N, it represents an entry to the code object that starts at line N.
+892 If the ending ling number is -N, it's an exit from the code object that
+893 starts at line N.
+ +895 """
+896 self._start_using()
+897 with self._connect() as con:
+898 file_id = self._file_id(filename)
+899 if file_id is None:
+900 return None
+901 else:
+902 query = "select distinct fromno, tono from arc where file_id = ?"
+903 data = [file_id]
+904 if self._query_context_ids is not None:
+905 ids_array = ', '.join('?' * len(self._query_context_ids))
+906 query += " and context_id in (" + ids_array + ")"
+907 data += self._query_context_ids
+908 arcs = con.execute(query, data)
+909 return list(arcs)
+ +911 def contexts_by_lineno(self, filename):
+912 """Get the contexts for each line in a file.
+ +914 Returns:
+915 A dict mapping line numbers to a list of context names.
+ +917 .. versionadded:: 5.0
+ +919 """
+920 lineno_contexts_map = collections.defaultdict(list)
+921 self._start_using()
+922 with self._connect() as con:
+923 file_id = self._file_id(filename)
+924 if file_id is None:
+925 return lineno_contexts_map
+926 if self.has_arcs():
+927 query = (
+928 "select arc.fromno, arc.tono, context.context "
+929 "from arc, context "
+930 "where arc.file_id = ? and arc.context_id = context.id"
+931 )
+932 data = [file_id]
+933 if self._query_context_ids is not None: 933 ↛ 934line 933 didn't jump to line 934, because the condition on line 933 was never true
+934 ids_array = ', '.join('?' * len(self._query_context_ids))
+935 query += " and arc.context_id in (" + ids_array + ")"
+936 data += self._query_context_ids
+937 for fromno, tono, context in con.execute(query, data):
+938 if context not in lineno_contexts_map[fromno]:
+939 lineno_contexts_map[fromno].append(context)
+940 if context not in lineno_contexts_map[tono]:
+941 lineno_contexts_map[tono].append(context)
+942 else:
+943 query = (
+944 "select l.numbits, c.context from line_bits l, context c "
+945 "where l.context_id = c.id "
+946 "and file_id = ?"
+947 )
+948 data = [file_id]
+949 if self._query_context_ids is not None:
+950 ids_array = ', '.join('?' * len(self._query_context_ids))
+951 query += " and l.context_id in (" + ids_array + ")"
+952 data += self._query_context_ids
+953 for numbits, context in con.execute(query, data):
+954 for lineno in numbits_to_nums(numbits):
+955 lineno_contexts_map[lineno].append(context)
+956 return lineno_contexts_map
+ +958 @classmethod
+959 def sys_info(cls):
+960 """Our information for `Coverage.sys_info`.
+ +962 Returns a list of (key, value) pairs.
+ +964 """
+965 with SqliteDb(":memory:", debug=NoDebugging()) as db:
+966 temp_store = [row[0] for row in db.execute("pragma temp_store")]
+967 compile_options = [row[0] for row in db.execute("pragma compile_options")]
+ +969 return [
+970 ('sqlite3_version', sqlite3.version),
+971 ('sqlite3_sqlite_version', sqlite3.sqlite_version),
+972 ('sqlite3_temp_store', temp_store),
+973 ('sqlite3_compile_options', compile_options),
+974 ]
+ + +977class SqliteDb(SimpleReprMixin):
+978 """A simple abstraction over a SQLite database.
+ +980 Use as a context manager, then you can use it like a
+981 :class:`python:sqlite3.Connection` object::
+ +983 with SqliteDb(filename, debug_control) as db:
+984 db.execute("insert into schema (version) values (?)", (SCHEMA_VERSION,))
+ +986 """
+987 def __init__(self, filename, debug):
+988 self.debug = debug if debug.should('sql') else None
+989 self.filename = filename
+990 self.nest = 0
+991 self.con = None
+ +993 def _connect(self):
+994 """Connect to the db and do universal initialization."""
+995 if self.con is not None:
+996 return
+ +998 # SQLite on Windows on py2 won't open a file if the filename argument
+999 # has non-ascii characters in it. Opening a relative file name avoids
+1000 # a problem if the current directory has non-ascii.
+1001 filename = self.filename
+1002 if env.WINDOWS and env.PY2:
+1003 try:
+1004 filename = os.path.relpath(self.filename)
+1005 except ValueError:
+1006 # ValueError can be raised under Windows when os.getcwd() returns a
+1007 # folder from a different drive than the drive of self.filename in
+1008 # which case we keep the original value of self.filename unchanged,
+1009 # hoping that we won't face the non-ascii directory problem.
+1010 pass
+ +1012 # It can happen that Python switches threads while the tracer writes
+1013 # data. The second thread will also try to write to the data,
+1014 # effectively causing a nested context. However, given the idempotent
+1015 # nature of the tracer operations, sharing a connection among threads
+1016 # is not a problem.
+1017 if self.debug: 1017 ↛ 1018line 1017 didn't jump to line 1018, because the condition on line 1017 was never true
+1018 self.debug.write("Connecting to {!r}".format(self.filename))
+1019 self.con = sqlite3.connect(filename, check_same_thread=False)
+1020 self.con.create_function('REGEXP', 2, _regexp)
+ +1022 # This pragma makes writing faster. It disables rollbacks, but we never need them.
+1023 # PyPy needs the .close() calls here, or sqlite gets twisted up:
+1024 # https://bitbucket.org/pypy/pypy/issues/2872/default-isolation-mode-is-different-on
+1025 self.execute("pragma journal_mode=off").close()
+1026 # This pragma makes writing faster.
+1027 self.execute("pragma synchronous=off").close()
+ +1029 def close(self):
+1030 """If needed, close the connection."""
+1031 if self.con is not None and self.filename != ":memory:":
+1032 self.con.close()
+1033 self.con = None
+ +1035 def __enter__(self):
+1036 if self.nest == 0:
+1037 self._connect()
+1038 self.con.__enter__()
+1039 self.nest += 1
+1040 return self
+ +1042 def __exit__(self, exc_type, exc_value, traceback):
+1043 self.nest -= 1
+1044 if self.nest == 0:
+1045 try:
+1046 self.con.__exit__(exc_type, exc_value, traceback)
+1047 self.close()
+1048 except Exception as exc:
+1049 if self.debug:
+1050 self.debug.write("EXCEPTION from __exit__: {}".format(exc))
+1051 raise
+ +1053 def execute(self, sql, parameters=()):
+1054 """Same as :meth:`python:sqlite3.Connection.execute`."""
+1055 if self.debug: 1055 ↛ 1056line 1055 didn't jump to line 1056, because the condition on line 1055 was never true
+1056 tail = " with {!r}".format(parameters) if parameters else ""
+1057 self.debug.write("Executing {!r}{}".format(sql, tail))
+1058 try:
+1059 try:
+1060 return self.con.execute(sql, parameters)
+1061 except Exception:
+1062 # In some cases, an error might happen that isn't really an
+1063 # error. Try again immediately.
+1064 # https://github.com/nedbat/coveragepy/issues/1010
+1065 return self.con.execute(sql, parameters)
+1066 except sqlite3.Error as exc:
+1067 msg = str(exc)
+1068 try:
+1069 # `execute` is the first thing we do with the database, so try
+1070 # hard to provide useful hints if something goes wrong now.
+1071 with open(self.filename, "rb") as bad_file:
+1072 cov4_sig = b"!coverage.py: This is a private format"
+1073 if bad_file.read(len(cov4_sig)) == cov4_sig:
+1074 msg = (
+1075 "Looks like a coverage 4.x data file. "
+1076 "Are you mixing versions of coverage?"
+1077 )
+1078 except Exception:
+1079 pass
+1080 if self.debug: 1080 ↛ 1081line 1080 didn't jump to line 1081, because the condition on line 1080 was never true
+1081 self.debug.write("EXCEPTION from execute: {}".format(msg))
+1082 raise CoverageException("Couldn't use data file {!r}: {}".format(self.filename, msg))
+ +1084 def execute_one(self, sql, parameters=()):
+1085 """Execute a statement and return the one row that results.
+ +1087 This is like execute(sql, parameters).fetchone(), except it is
+1088 correct in reading the entire result set. This will raise an
+1089 exception if more than one row results.
+ +1091 Returns a row, or None if there were no rows.
+1092 """
+1093 rows = list(self.execute(sql, parameters))
+1094 if len(rows) == 0:
+1095 return None
+1096 elif len(rows) == 1: 1096 ↛ 1099line 1096 didn't jump to line 1099, because the condition on line 1096 was never false
+1097 return rows[0]
+1098 else:
+1099 raise CoverageException("Sql {!r} shouldn't return {} rows".format(sql, len(rows)))
+ +1101 def executemany(self, sql, data):
+1102 """Same as :meth:`python:sqlite3.Connection.executemany`."""
+1103 if self.debug: 1103 ↛ 1104line 1103 didn't jump to line 1104, because the condition on line 1103 was never true
+1104 data = list(data)
+1105 self.debug.write("Executing many {!r} with {} rows".format(sql, len(data)))
+1106 return self.con.executemany(sql, data)
+ +1108 def executescript(self, script):
+1109 """Same as :meth:`python:sqlite3.Connection.executescript`."""
+1110 if self.debug: 1110 ↛ 1111line 1110 didn't jump to line 1111, because the condition on line 1110 was never true
+1111 self.debug.write("Executing script with {} chars: {}".format(
+1112 len(script), clipped_repr(script, 100),
+1113 ))
+1114 self.con.executescript(script)
+ +1116 def dump(self):
+1117 """Return a multi-line string, the SQL dump of the database."""
+1118 return "\n".join(self.con.iterdump())
+ + +1121def _regexp(text, pattern):
+1122 """A regexp function for SQLite."""
+1123 return re.search(text, pattern) is not None
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""Summary reporting"""
+ +6import sys
+ +8from coverage import env
+9from coverage.report import get_analysis_to_report
+10from coverage.results import Numbers
+11from coverage.misc import CoverageException, output_encoding
+ + +14class SummaryReporter(object):
+15 """A reporter for writing the summary report."""
+ +17 def __init__(self, coverage):
+18 self.coverage = coverage
+19 self.config = self.coverage.config
+20 self.branches = coverage.get_data().has_arcs()
+21 self.outfile = None
+22 self.fr_analysis = []
+23 self.skipped_count = 0
+24 self.empty_count = 0
+25 self.total = Numbers()
+26 self.fmt_err = u"%s %s: %s"
+ +28 def writeout(self, line):
+29 """Write a line to the output, adding a newline."""
+30 if env.PY2:
+31 line = line.encode(output_encoding())
+32 self.outfile.write(line.rstrip())
+33 self.outfile.write("\n")
+ +35 def report(self, morfs, outfile=None):
+36 """Writes a report summarizing coverage statistics per module.
+ +38 `outfile` is a file object to write the summary to. It must be opened
+39 for native strings (bytes on Python 2, Unicode on Python 3).
+ +41 """
+42 self.outfile = outfile or sys.stdout
+ +44 self.coverage.get_data().set_query_contexts(self.config.report_contexts)
+45 for fr, analysis in get_analysis_to_report(self.coverage, morfs):
+46 self.report_one_file(fr, analysis)
+ +48 # Prepare the formatting strings, header, and column sorting.
+49 max_name = max([len(fr.relative_filename()) for (fr, analysis) in self.fr_analysis] + [5])
+50 fmt_name = u"%%- %ds " % max_name
+51 fmt_skip_covered = u"\n%s file%s skipped due to complete coverage."
+52 fmt_skip_empty = u"\n%s empty file%s skipped."
+ +54 header = (fmt_name % "Name") + u" Stmts Miss"
+55 fmt_coverage = fmt_name + u"%6d %6d"
+56 if self.branches:
+57 header += u" Branch BrPart"
+58 fmt_coverage += u" %6d %6d"
+59 width100 = Numbers.pc_str_width()
+60 header += u"%*s" % (width100+4, "Cover")
+61 fmt_coverage += u"%%%ds%%%%" % (width100+3,)
+62 if self.config.show_missing:
+63 header += u" Missing"
+64 fmt_coverage += u" %s"
+65 rule = u"-" * len(header)
+ +67 column_order = dict(name=0, stmts=1, miss=2, cover=-1)
+68 if self.branches:
+69 column_order.update(dict(branch=3, brpart=4))
+ +71 # Write the header
+72 self.writeout(header)
+73 self.writeout(rule)
+ +75 # `lines` is a list of pairs, (line text, line values). The line text
+76 # is a string that will be printed, and line values is a tuple of
+77 # sortable values.
+78 lines = []
+ +80 for (fr, analysis) in self.fr_analysis:
+81 nums = analysis.numbers
+ +83 args = (fr.relative_filename(), nums.n_statements, nums.n_missing)
+84 if self.branches:
+85 args += (nums.n_branches, nums.n_partial_branches)
+86 args += (nums.pc_covered_str,)
+87 if self.config.show_missing:
+88 args += (analysis.missing_formatted(branches=True),)
+89 text = fmt_coverage % args
+90 # Add numeric percent coverage so that sorting makes sense.
+91 args += (nums.pc_covered,)
+92 lines.append((text, args))
+ +94 # Sort the lines and write them out.
+95 if getattr(self.config, 'sort', None):
+96 sort_option = self.config.sort.lower()
+97 reverse = False
+98 if sort_option[0] == '-':
+99 reverse = True
+100 sort_option = sort_option[1:]
+101 elif sort_option[0] == '+':
+102 sort_option = sort_option[1:]
+ +104 position = column_order.get(sort_option)
+105 if position is None:
+106 raise CoverageException("Invalid sorting option: {!r}".format(self.config.sort))
+107 lines.sort(key=lambda l: (l[1][position], l[0]), reverse=reverse)
+ +109 for line in lines:
+110 self.writeout(line[0])
+ +112 # Write a TOTAL line if we had at least one file.
+113 if self.total.n_files > 0:
+114 self.writeout(rule)
+115 args = ("TOTAL", self.total.n_statements, self.total.n_missing)
+116 if self.branches:
+117 args += (self.total.n_branches, self.total.n_partial_branches)
+118 args += (self.total.pc_covered_str,)
+119 if self.config.show_missing:
+120 args += ("",)
+121 self.writeout(fmt_coverage % args)
+ +123 # Write other final lines.
+124 if not self.total.n_files and not self.skipped_count:
+125 raise CoverageException("No data to report.")
+ +127 if self.config.skip_covered and self.skipped_count:
+128 self.writeout(
+129 fmt_skip_covered % (self.skipped_count, 's' if self.skipped_count > 1 else '')
+130 )
+131 if self.config.skip_empty and self.empty_count:
+132 self.writeout(
+133 fmt_skip_empty % (self.empty_count, 's' if self.empty_count > 1 else '')
+134 )
+ +136 return self.total.n_statements and self.total.pc_covered
+ +138 def report_one_file(self, fr, analysis):
+139 """Report on just one file, the callback from report()."""
+140 nums = analysis.numbers
+141 self.total += nums
+ +143 no_missing_lines = (nums.n_missing == 0)
+144 no_missing_branches = (nums.n_partial_branches == 0)
+145 if self.config.skip_covered and no_missing_lines and no_missing_branches:
+146 # Don't report on 100% files.
+147 self.skipped_count += 1
+148 elif self.config.skip_empty and nums.n_statements == 0:
+149 # Don't report on empty files.
+150 self.empty_count += 1
+151 else:
+152 self.fr_analysis.append((fr, analysis))
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""A simple Python template renderer, for a nano-subset of Django syntax.
+ +6For a detailed discussion of this code, see this chapter from 500 Lines:
+7http://aosabook.org/en/500L/a-template-engine.html
+ +9"""
+ +11# Coincidentally named the same as http://code.activestate.com/recipes/496702/
+ +13import re
+ +15from coverage import env
+ + +18class TempliteSyntaxError(ValueError):
+19 """Raised when a template has a syntax error."""
+20 pass
+ + +23class TempliteValueError(ValueError):
+24 """Raised when an expression won't evaluate in a template."""
+25 pass
+ + +28class CodeBuilder(object):
+29 """Build source code conveniently."""
+ +31 def __init__(self, indent=0):
+32 self.code = []
+33 self.indent_level = indent
+ +35 def __str__(self):
+36 return "".join(str(c) for c in self.code)
+ +38 def add_line(self, line):
+39 """Add a line of source to the code.
+ +41 Indentation and newline will be added for you, don't provide them.
+ +43 """
+44 self.code.extend([" " * self.indent_level, line, "\n"])
+ +46 def add_section(self):
+47 """Add a section, a sub-CodeBuilder."""
+48 section = CodeBuilder(self.indent_level)
+49 self.code.append(section)
+50 return section
+ +52 INDENT_STEP = 4 # PEP8 says so!
+ +54 def indent(self):
+55 """Increase the current indent for following lines."""
+56 self.indent_level += self.INDENT_STEP
+ +58 def dedent(self):
+59 """Decrease the current indent for following lines."""
+60 self.indent_level -= self.INDENT_STEP
+ +62 def get_globals(self):
+63 """Execute the code, and return a dict of globals it defines."""
+64 # A check that the caller really finished all the blocks they started.
+65 assert self.indent_level == 0
+66 # Get the Python source as a single string.
+67 python_source = str(self)
+68 # Execute the source, defining globals, and return them.
+69 global_namespace = {}
+70 exec(python_source, global_namespace)
+71 return global_namespace
+ + +74class Templite(object):
+75 """A simple template renderer, for a nano-subset of Django syntax.
+ +77 Supported constructs are extended variable access::
+ +79 {{var.modifier.modifier|filter|filter}}
+ +81 loops::
+ +83 {% for var in list %}...{% endfor %}
+ +85 and ifs::
+ +87 {% if var %}...{% endif %}
+ +89 Comments are within curly-hash markers::
+ +91 {# This will be ignored #}
+ +93 Lines between `{% joined %}` and `{% endjoined %}` will have lines stripped
+94 and joined. Be careful, this could join words together!
+ +96 Any of these constructs can have a hyphen at the end (`-}}`, `-%}`, `-#}`),
+97 which will collapse the whitespace following the tag.
+ +99 Construct a Templite with the template text, then use `render` against a
+100 dictionary context to create a finished string::
+ +102 templite = Templite('''
+103 <h1>Hello {{name|upper}}!</h1>
+104 {% for topic in topics %}
+105 <p>You are interested in {{topic}}.</p>
+106 {% endif %}
+107 ''',
+108 {'upper': str.upper},
+109 )
+110 text = templite.render({
+111 'name': "Ned",
+112 'topics': ['Python', 'Geometry', 'Juggling'],
+113 })
+ +115 """
+116 def __init__(self, text, *contexts):
+117 """Construct a Templite with the given `text`.
+ +119 `contexts` are dictionaries of values to use for future renderings.
+120 These are good for filters and global values.
+ +122 """
+123 self.context = {}
+124 for context in contexts:
+125 self.context.update(context)
+ +127 self.all_vars = set()
+128 self.loop_vars = set()
+ +130 # We construct a function in source form, then compile it and hold onto
+131 # it, and execute it to render the template.
+132 code = CodeBuilder()
+ +134 code.add_line("def render_function(context, do_dots):")
+135 code.indent()
+136 vars_code = code.add_section()
+137 code.add_line("result = []")
+138 code.add_line("append_result = result.append")
+139 code.add_line("extend_result = result.extend")
+140 if env.PY2:
+141 code.add_line("to_str = unicode")
+142 else:
+143 code.add_line("to_str = str")
+ +145 buffered = []
+ +147 def flush_output():
+148 """Force `buffered` to the code builder."""
+149 if len(buffered) == 1:
+150 code.add_line("append_result(%s)" % buffered[0])
+151 elif len(buffered) > 1:
+152 code.add_line("extend_result([%s])" % ", ".join(buffered))
+153 del buffered[:]
+ +155 ops_stack = []
+ +157 # Split the text to form a list of tokens.
+158 tokens = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)
+ +160 squash = in_joined = False
+ +162 for token in tokens:
+163 if token.startswith('{'):
+164 start, end = 2, -2
+165 squash = (token[-3] == '-')
+166 if squash:
+167 end = -3
+ +169 if token.startswith('{#'):
+170 # Comment: ignore it and move on.
+171 continue
+172 elif token.startswith('{{'):
+173 # An expression to evaluate.
+174 expr = self._expr_code(token[start:end].strip())
+175 buffered.append("to_str(%s)" % expr)
+176 else:
+177 # token.startswith('{%')
+178 # Action tag: split into words and parse further.
+179 flush_output()
+ +181 words = token[start:end].strip().split()
+182 if words[0] == 'if':
+183 # An if statement: evaluate the expression to determine if.
+184 if len(words) != 2:
+185 self._syntax_error("Don't understand if", token)
+186 ops_stack.append('if')
+187 code.add_line("if %s:" % self._expr_code(words[1]))
+188 code.indent()
+189 elif words[0] == 'for':
+190 # A loop: iterate over expression result.
+191 if len(words) != 4 or words[2] != 'in':
+192 self._syntax_error("Don't understand for", token)
+193 ops_stack.append('for')
+194 self._variable(words[1], self.loop_vars)
+195 code.add_line(
+196 "for c_%s in %s:" % (
+197 words[1],
+198 self._expr_code(words[3])
+199 )
+200 )
+201 code.indent()
+202 elif words[0] == 'joined':
+203 ops_stack.append('joined')
+204 in_joined = True
+205 elif words[0].startswith('end'):
+206 # Endsomething. Pop the ops stack.
+207 if len(words) != 1:
+208 self._syntax_error("Don't understand end", token)
+209 end_what = words[0][3:]
+210 if not ops_stack:
+211 self._syntax_error("Too many ends", token)
+212 start_what = ops_stack.pop()
+213 if start_what != end_what:
+214 self._syntax_error("Mismatched end tag", end_what)
+215 if end_what == 'joined':
+216 in_joined = False
+217 else:
+218 code.dedent()
+219 else:
+220 self._syntax_error("Don't understand tag", words[0])
+221 else:
+222 # Literal content. If it isn't empty, output it.
+223 if in_joined:
+224 token = re.sub(r"\s*\n\s*", "", token.strip())
+225 elif squash:
+226 token = token.lstrip()
+227 if token:
+228 buffered.append(repr(token))
+ +230 if ops_stack:
+231 self._syntax_error("Unmatched action tag", ops_stack[-1])
+ +233 flush_output()
+ +235 for var_name in self.all_vars - self.loop_vars:
+236 vars_code.add_line("c_%s = context[%r]" % (var_name, var_name))
+ +238 code.add_line('return "".join(result)')
+239 code.dedent()
+240 self._render_function = code.get_globals()['render_function']
+ +242 def _expr_code(self, expr):
+243 """Generate a Python expression for `expr`."""
+244 if "|" in expr:
+245 pipes = expr.split("|")
+246 code = self._expr_code(pipes[0])
+247 for func in pipes[1:]:
+248 self._variable(func, self.all_vars)
+249 code = "c_%s(%s)" % (func, code)
+250 elif "." in expr:
+251 dots = expr.split(".")
+252 code = self._expr_code(dots[0])
+253 args = ", ".join(repr(d) for d in dots[1:])
+254 code = "do_dots(%s, %s)" % (code, args)
+255 else:
+256 self._variable(expr, self.all_vars)
+257 code = "c_%s" % expr
+258 return code
+ +260 def _syntax_error(self, msg, thing):
+261 """Raise a syntax error using `msg`, and showing `thing`."""
+262 raise TempliteSyntaxError("%s: %r" % (msg, thing))
+ +264 def _variable(self, name, vars_set):
+265 """Track that `name` is used as a variable.
+ +267 Adds the name to `vars_set`, a set of variable names.
+ +269 Raises an syntax error if `name` is not a valid name.
+ +271 """
+272 if not re.match(r"[_a-zA-Z][_a-zA-Z0-9]*$", name):
+273 self._syntax_error("Not a valid name", name)
+274 vars_set.add(name)
+ +276 def render(self, context=None):
+277 """Render this template by applying it to `context`.
+ +279 `context` is a dictionary of values to use in this rendering.
+ +281 """
+282 # Make the complete context we'll use.
+283 render_context = dict(self.context)
+284 if context:
+285 render_context.update(context)
+286 return self._render_function(render_context, self._do_dots)
+ +288 def _do_dots(self, value, *dots):
+289 """Evaluate dotted expressions at run-time."""
+290 for dot in dots:
+291 try:
+292 value = getattr(value, dot)
+293 except AttributeError:
+294 try:
+295 value = value[dot]
+296 except (TypeError, KeyError):
+297 raise TempliteValueError(
+298 "Couldn't evaluate %r.%s" % (value, dot)
+299 )
+300 if callable(value):
+301 value = value()
+302 return value
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""TOML configuration support for coverage.py"""
+ +6import io
+7import os
+8import re
+ +10from coverage import env
+11from coverage.backward import configparser, path_types
+12from coverage.misc import CoverageException, substitute_variables
+ +14# TOML support is an install-time extra option.
+15try:
+16 import toml
+17except ImportError: # pragma: not covered
+18 toml = None
+ + +21class TomlDecodeError(Exception):
+22 """An exception class that exists even when toml isn't installed."""
+23 pass
+ + +26class TomlConfigParser:
+27 """TOML file reading with the interface of HandyConfigParser."""
+ +29 # This class has the same interface as config.HandyConfigParser, no
+30 # need for docstrings.
+31 # pylint: disable=missing-function-docstring
+ +33 def __init__(self, our_file):
+34 self.our_file = our_file
+35 self.data = None
+ +37 def read(self, filenames):
+38 # RawConfigParser takes a filename or list of filenames, but we only
+39 # ever call this with a single filename.
+40 assert isinstance(filenames, path_types)
+41 filename = filenames
+42 if env.PYVERSION >= (3, 6):
+43 filename = os.fspath(filename)
+ +45 try:
+46 with io.open(filename, encoding='utf-8') as fp:
+47 toml_text = fp.read()
+48 except IOError:
+49 return []
+50 if toml:
+51 toml_text = substitute_variables(toml_text, os.environ)
+52 try:
+53 self.data = toml.loads(toml_text)
+54 except toml.TomlDecodeError as err:
+55 raise TomlDecodeError(*err.args)
+56 return [filename]
+57 else:
+58 has_toml = re.search(r"^\[tool\.coverage\.", toml_text, flags=re.MULTILINE)
+59 if self.our_file or has_toml:
+60 # Looks like they meant to read TOML, but we can't read it.
+61 msg = "Can't read {!r} without TOML support. Install with [toml] extra"
+62 raise CoverageException(msg.format(filename))
+63 return []
+ +65 def _get_section(self, section):
+66 """Get a section from the data.
+ +68 Arguments:
+69 section (str): A section name, which can be dotted.
+ +71 Returns:
+72 name (str): the actual name of the section that was found, if any,
+73 or None.
+74 data (str): the dict of data in the section, or None if not found.
+ +76 """
+77 prefixes = ["tool.coverage."]
+78 if self.our_file:
+79 prefixes.append("")
+80 for prefix in prefixes:
+81 real_section = prefix + section
+82 parts = real_section.split(".")
+83 try:
+84 data = self.data[parts[0]]
+85 for part in parts[1:]:
+86 data = data[part]
+87 except KeyError:
+88 continue
+89 break
+90 else:
+91 return None, None
+92 return real_section, data
+ +94 def _get(self, section, option):
+95 """Like .get, but returns the real section name and the value."""
+96 name, data = self._get_section(section)
+97 if data is None: 97 ↛ 98line 97 didn't jump to line 98, because the condition on line 97 was never true
+98 raise configparser.NoSectionError(section)
+99 try:
+100 return name, data[option]
+101 except KeyError:
+102 raise configparser.NoOptionError(option, name)
+ +104 def has_option(self, section, option):
+105 _, data = self._get_section(section)
+106 if data is None:
+107 return False
+108 return option in data
+ +110 def has_section(self, section):
+111 name, _ = self._get_section(section)
+112 return name
+ +114 def options(self, section):
+115 _, data = self._get_section(section)
+116 if data is None: 116 ↛ 117line 116 didn't jump to line 117, because the condition on line 116 was never true
+117 raise configparser.NoSectionError(section)
+118 return list(data.keys())
+ +120 def get_section(self, section):
+121 _, data = self._get_section(section)
+122 return data
+ +124 def get(self, section, option):
+125 _, value = self._get(section, option)
+126 return value
+ +128 def _check_type(self, section, option, value, type_, type_desc):
+129 if not isinstance(value, type_):
+130 raise ValueError(
+131 'Option {!r} in section {!r} is not {}: {!r}'
+132 .format(option, section, type_desc, value)
+133 )
+ +135 def getboolean(self, section, option):
+136 name, value = self._get(section, option)
+137 self._check_type(name, option, value, bool, "a boolean")
+138 return value
+ +140 def getlist(self, section, option):
+141 name, values = self._get(section, option)
+142 self._check_type(name, option, values, list, "a list")
+143 return values
+ +145 def getregexlist(self, section, option):
+146 name, values = self._get(section, option)
+147 self._check_type(name, option, values, list, "a list")
+148 for value in values:
+149 value = value.strip()
+150 try:
+151 re.compile(value)
+152 except re.error as e:
+153 raise CoverageException(
+154 "Invalid [%s].%s value %r: %s" % (name, option, value, e)
+155 )
+156 return values
+ +158 def getint(self, section, option):
+159 name, value = self._get(section, option)
+160 self._check_type(name, option, value, int, "an integer")
+161 return value
+ +163 def getfloat(self, section, option):
+164 name, value = self._get(section, option)
+165 if isinstance(value, int):
+166 value = float(value)
+167 self._check_type(name, option, value, float, "a float")
+168 return value
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+2# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +4"""The version and URL for coverage.py"""
+5# This file is exec'ed in setup.py, don't import anything!
+ +7# Same semantics as sys.version_info.
+8version_info = (5, 5, 1, "alpha", 0)
+ + +11def _make_version(major, minor, micro, releaselevel, serial):
+12 """Create a readable version string from version_info tuple components."""
+13 assert releaselevel in ['alpha', 'beta', 'candidate', 'final']
+14 version = "%d.%d" % (major, minor)
+15 if micro:
+16 version += ".%d" % (micro,)
+17 if releaselevel != 'final':
+18 short = {'alpha': 'a', 'beta': 'b', 'candidate': 'rc'}[releaselevel]
+19 version += "%s%d" % (short, serial)
+20 return version
+ + +23def _make_url(major, minor, micro, releaselevel, serial):
+24 """Make the URL people should start at for this version of coverage.py."""
+25 url = "https://coverage.readthedocs.io"
+26 if releaselevel != 'final':
+27 # For pre-releases, use a version-specific URL.
+28 url += "/en/coverage-" + _make_version(major, minor, micro, releaselevel, serial)
+29 return url
+ + +32__version__ = _make_version(*version_info)
+33__url__ = _make_url(*version_info)
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+1# coding: utf-8
+2# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+3# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+ +5"""XML reporting for coverage.py"""
+ +7import os
+8import os.path
+9import sys
+10import time
+11import xml.dom.minidom
+ +13from coverage import env
+14from coverage import __url__, __version__, files
+15from coverage.backward import iitems
+16from coverage.misc import isolate_module
+17from coverage.report import get_analysis_to_report
+ +19os = isolate_module(os)
+ + +22DTD_URL = 'https://raw.githubusercontent.com/cobertura/web/master/htdocs/xml/coverage-04.dtd'
+ + +25def rate(hit, num):
+26 """Return the fraction of `hit`/`num`, as a string."""
+27 if num == 0:
+28 return "1"
+29 else:
+30 return "%.4g" % (float(hit) / num)
+ + +33class XmlReporter(object):
+34 """A reporter for writing Cobertura-style XML coverage results."""
+ +36 def __init__(self, coverage):
+37 self.coverage = coverage
+38 self.config = self.coverage.config
+ +40 self.source_paths = set()
+41 if self.config.source:
+42 for src in self.config.source:
+43 if os.path.exists(src):
+44 if not self.config.relative_files:
+45 src = files.canonical_filename(src)
+46 self.source_paths.add(src)
+47 self.packages = {}
+48 self.xml_out = None
+ +50 def report(self, morfs, outfile=None):
+51 """Generate a Cobertura-compatible XML report for `morfs`.
+ +53 `morfs` is a list of modules or file names.
+ +55 `outfile` is a file object to write the XML to.
+ +57 """
+58 # Initial setup.
+59 outfile = outfile or sys.stdout
+60 has_arcs = self.coverage.get_data().has_arcs()
+ +62 # Create the DOM that will store the data.
+63 impl = xml.dom.minidom.getDOMImplementation()
+64 self.xml_out = impl.createDocument(None, "coverage", None)
+ +66 # Write header stuff.
+67 xcoverage = self.xml_out.documentElement
+68 xcoverage.setAttribute("version", __version__)
+69 xcoverage.setAttribute("timestamp", str(int(time.time()*1000)))
+70 xcoverage.appendChild(self.xml_out.createComment(
+71 " Generated by coverage.py: %s " % __url__
+72 ))
+73 xcoverage.appendChild(self.xml_out.createComment(" Based on %s " % DTD_URL))
+ +75 # Call xml_file for each file in the data.
+76 for fr, analysis in get_analysis_to_report(self.coverage, morfs):
+77 self.xml_file(fr, analysis, has_arcs)
+ +79 xsources = self.xml_out.createElement("sources")
+80 xcoverage.appendChild(xsources)
+ +82 # Populate the XML DOM with the source info.
+83 for path in sorted(self.source_paths):
+84 xsource = self.xml_out.createElement("source")
+85 xsources.appendChild(xsource)
+86 txt = self.xml_out.createTextNode(path)
+87 xsource.appendChild(txt)
+ +89 lnum_tot, lhits_tot = 0, 0
+90 bnum_tot, bhits_tot = 0, 0
+ +92 xpackages = self.xml_out.createElement("packages")
+93 xcoverage.appendChild(xpackages)
+ +95 # Populate the XML DOM with the package info.
+96 for pkg_name, pkg_data in sorted(iitems(self.packages)):
+97 class_elts, lhits, lnum, bhits, bnum = pkg_data
+98 xpackage = self.xml_out.createElement("package")
+99 xpackages.appendChild(xpackage)
+100 xclasses = self.xml_out.createElement("classes")
+101 xpackage.appendChild(xclasses)
+102 for _, class_elt in sorted(iitems(class_elts)):
+103 xclasses.appendChild(class_elt)
+104 xpackage.setAttribute("name", pkg_name.replace(os.sep, '.'))
+105 xpackage.setAttribute("line-rate", rate(lhits, lnum))
+106 if has_arcs:
+107 branch_rate = rate(bhits, bnum)
+108 else:
+109 branch_rate = "0"
+110 xpackage.setAttribute("branch-rate", branch_rate)
+111 xpackage.setAttribute("complexity", "0")
+ +113 lnum_tot += lnum
+114 lhits_tot += lhits
+115 bnum_tot += bnum
+116 bhits_tot += bhits
+ +118 xcoverage.setAttribute("lines-valid", str(lnum_tot))
+119 xcoverage.setAttribute("lines-covered", str(lhits_tot))
+120 xcoverage.setAttribute("line-rate", rate(lhits_tot, lnum_tot))
+121 if has_arcs:
+122 xcoverage.setAttribute("branches-valid", str(bnum_tot))
+123 xcoverage.setAttribute("branches-covered", str(bhits_tot))
+124 xcoverage.setAttribute("branch-rate", rate(bhits_tot, bnum_tot))
+125 else:
+126 xcoverage.setAttribute("branches-covered", "0")
+127 xcoverage.setAttribute("branches-valid", "0")
+128 xcoverage.setAttribute("branch-rate", "0")
+129 xcoverage.setAttribute("complexity", "0")
+ +131 # Write the output file.
+132 outfile.write(serialize_xml(self.xml_out))
+ +134 # Return the total percentage.
+135 denom = lnum_tot + bnum_tot
+136 if denom == 0:
+137 pct = 0.0
+138 else:
+139 pct = 100.0 * (lhits_tot + bhits_tot) / denom
+140 return pct
+ +142 def xml_file(self, fr, analysis, has_arcs):
+143 """Add to the XML report for a single file."""
+ +145 if self.config.skip_empty:
+146 if analysis.numbers.n_statements == 0:
+147 return
+ +149 # Create the 'lines' and 'package' XML elements, which
+150 # are populated later. Note that a package == a directory.
+151 filename = fr.filename.replace("\\", "/")
+152 for source_path in self.source_paths:
+153 source_path = files.canonical_filename(source_path)
+154 if filename.startswith(source_path.replace("\\", "/") + "/"):
+155 rel_name = filename[len(source_path)+1:]
+156 break
+157 else:
+158 rel_name = fr.relative_filename()
+159 self.source_paths.add(fr.filename[:-len(rel_name)].rstrip(r"\/"))
+ +161 dirname = os.path.dirname(rel_name) or u"."
+162 dirname = "/".join(dirname.split("/")[:self.config.xml_package_depth])
+163 package_name = dirname.replace("/", ".")
+ +165 package = self.packages.setdefault(package_name, [{}, 0, 0, 0, 0])
+ +167 xclass = self.xml_out.createElement("class")
+ +169 xclass.appendChild(self.xml_out.createElement("methods"))
+ +171 xlines = self.xml_out.createElement("lines")
+172 xclass.appendChild(xlines)
+ +174 xclass.setAttribute("name", os.path.relpath(rel_name, dirname))
+175 xclass.setAttribute("filename", rel_name.replace("\\", "/"))
+176 xclass.setAttribute("complexity", "0")
+ +178 branch_stats = analysis.branch_stats()
+179 missing_branch_arcs = analysis.missing_branch_arcs()
+ +181 # For each statement, create an XML 'line' element.
+182 for line in sorted(analysis.statements):
+183 xline = self.xml_out.createElement("line")
+184 xline.setAttribute("number", str(line))
+ +186 # Q: can we get info about the number of times a statement is
+187 # executed? If so, that should be recorded here.
+188 xline.setAttribute("hits", str(int(line not in analysis.missing)))
+ +190 if has_arcs:
+191 if line in branch_stats:
+192 total, taken = branch_stats[line]
+193 xline.setAttribute("branch", "true")
+194 xline.setAttribute(
+195 "condition-coverage",
+196 "%d%% (%d/%d)" % (100*taken//total, taken, total)
+197 )
+198 if line in missing_branch_arcs:
+199 annlines = ["exit" if b < 0 else str(b) for b in missing_branch_arcs[line]]
+200 xline.setAttribute("missing-branches", ",".join(annlines))
+201 xlines.appendChild(xline)
+ +203 class_lines = len(analysis.statements)
+204 class_hits = class_lines - len(analysis.missing)
+ +206 if has_arcs:
+207 class_branches = sum(t for t, k in branch_stats.values())
+208 missing_branches = sum(t - k for t, k in branch_stats.values())
+209 class_br_hits = class_branches - missing_branches
+210 else:
+211 class_branches = 0.0
+212 class_br_hits = 0.0
+ +214 # Finalize the statistics that are collected in the XML DOM.
+215 xclass.setAttribute("line-rate", rate(class_hits, class_lines))
+216 if has_arcs:
+217 branch_rate = rate(class_br_hits, class_branches)
+218 else:
+219 branch_rate = "0"
+220 xclass.setAttribute("branch-rate", branch_rate)
+ +222 package[0][rel_name] = xclass
+223 package[1] += class_hits
+224 package[2] += class_lines
+225 package[3] += class_br_hits
+226 package[4] += class_branches
+ + +229def serialize_xml(dom):
+230 """Serialize a minidom node to XML."""
+231 out = dom.toprettyxml()
+232 if env.PY2:
+233 out = out.encode("utf8")
+234 return out
+
+
+
+ Hot-keys on this page
++ n + s + m + x + b + p + c change column sorting +
+| Module | +statements | +missing | +excluded | +branches | +partial | +coverage | +
|---|---|---|---|---|---|---|
| Total | +13112 | +488 | +649 | +2795 | +113 | +95.266% | +
| coverage/__init__.py | +14 | +0 | +0 | +0 | +0 | +100.000% | +
| coverage/__main__.py | +4 | +0 | +0 | +0 | +0 | +100.000% | +
| coverage/annotate.py | +59 | +1 | +0 | +28 | +2 | +96.552% | +
| coverage/backward.py | +137 | +0 | +6 | +14 | +1 | +99.338% | +
| coverage/bytecode.py | +10 | +0 | +0 | +6 | +0 | +100.000% | +
| coverage/cmdline.py | +311 | +3 | +12 | +133 | +4 | +98.423% | +
| coverage/collector.py | +211 | +78 | +2 | +84 | +11 | +58.305% | +
| coverage/config.py | +263 | +0 | +0 | +108 | +0 | +100.000% | +
| coverage/context.py | +57 | +11 | +0 | +36 | +4 | +77.419% | +
| coverage/control.py | +376 | +34 | +8 | +148 | +14 | +88.931% | +
| coverage/data.py | +54 | +3 | +0 | +32 | +4 | +91.860% | +
| coverage/debug.py | +111 | +5 | +133 | +32 | +1 | +94.406% | +
| coverage/disposition.py | +20 | +6 | +0 | +4 | +0 | +58.333% | +
| coverage/env.py | +52 | +1 | +0 | +12 | +1 | +96.875% | +
| coverage/execfile.py | +203 | +24 | +0 | +75 | +5 | +86.691% | +
| coverage/files.py | +205 | +5 | +10 | +90 | +2 | +97.627% | +
| coverage/html.py | +247 | +0 | +0 | +96 | +0 | +100.000% | +
| coverage/inorout.py | +267 | +51 | +2 | +152 | +19 | +78.520% | +
| coverage/jsonreport.py | +37 | +0 | +0 | +8 | +0 | +100.000% | +
| coverage/misc.py | +162 | +3 | +10 | +64 | +5 | +96.460% | +
| coverage/multiproc.py | +63 | +8 | +0 | +14 | +3 | +85.714% | +
| coverage/numbits.py | +55 | +0 | +0 | +24 | +0 | +100.000% | +
| coverage/parser.py | +661 | +3 | +56 | +310 | +11 | +98.558% | +
| coverage/phystokens.py | +153 | +0 | +0 | +64 | +0 | +100.000% | +
| coverage/plugin.py | +67 | +10 | +2 | +2 | +0 | +85.507% | +
| coverage/plugin_support.py | +168 | +81 | +0 | +14 | +1 | +51.648% | +
| coverage/python.py | +136 | +5 | +4 | +42 | +1 | +96.629% | +
| coverage/pytracer.py | +121 | +102 | +2 | +54 | +0 | +12.000% | +
| coverage/report.py | +49 | +0 | +0 | +34 | +0 | +100.000% | +
| coverage/results.py | +183 | +0 | +1 | +58 | +0 | +100.000% | +
| coverage/sqldata.py | +488 | +26 | +0 | +226 | +16 | +93.557% | +
| coverage/summary.py | +100 | +0 | +0 | +46 | +0 | +100.000% | +
| coverage/templite.py | +151 | +0 | +0 | +66 | +0 | +100.000% | +
| coverage/tomlconfig.py | +111 | +4 | +2 | +24 | +2 | +95.556% | +
| coverage/version.py | +18 | +0 | +0 | +6 | +0 | +100.000% | +
| coverage/xmlreport.py | +150 | +0 | +0 | +52 | +0 | +100.000% | +
| tests/__init__.py | +1 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/conftest.py | +37 | +1 | +0 | +8 | +1 | +95.556% | +
| tests/coveragetest.py | +194 | +0 | +12 | +64 | +0 | +100.000% | +
| tests/covmain.zip/__main__.py | +4 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/covmodzip1.py | +2 | +2 | +0 | +0 | +0 | +0.000% | +
| tests/goldtest.py | +76 | +0 | +9 | +24 | +0 | +100.000% | +
| tests/helpers.py | +117 | +0 | +0 | +36 | +0 | +100.000% | +
| tests/mixins.py | +69 | +0 | +0 | +11 | +0 | +100.000% | +
| tests/modules/aa/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/aa/afile.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/aa/bb/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/aa/bb/bfile.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/aa/bb/cc/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/aa/bb/cc/cfile.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg1/__init__.py | +1 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg1/__main__.py | +2 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg1/runmod2.py | +2 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg1/sub/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg1/sub/__main__.py | +2 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg1/sub/runmod3.py | +2 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/pkg2/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/plugins/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/plugins/a_plugin.py | +5 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/plugins/another.py | +6 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/process_test/__init__.py | +0 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/modules/process_test/try_execfile.py | +44 | +1 | +0 | +27 | +1 | +97.183% | +
| tests/modules/runmod1.py | +2 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/osinfo.py | +27 | +0 | +4 | +4 | +0 | +100.000% | +
| tests/plugin1.py | +24 | +8 | +0 | +2 | +0 | +61.538% | +
| tests/plugin2.py | +27 | +10 | +0 | +4 | +0 | +54.839% | +
| tests/plugin_config.py | +11 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_annotate.py | +35 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_api.py | +662 | +1 | +54 | +24 | +0 | +99.854% | +
| tests/test_arcs.py | +335 | +0 | +2 | +70 | +0 | +100.000% | +
| tests/test_backward.py | +14 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_cmdline.py | +345 | +0 | +19 | +34 | +0 | +100.000% | +
| tests/test_collector.py | +15 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/test_concurrency.py | +228 | +0 | +36 | +48 | +0 | +100.000% | +
| tests/test_config.py | +347 | +0 | +0 | +6 | +0 | +100.000% | +
| tests/test_context.py | +174 | +0 | +0 | +19 | +0 | +100.000% | +
| tests/test_coverage.py | +324 | +0 | +0 | +22 | +0 | +100.000% | +
| tests/test_data.py | +563 | +0 | +0 | +8 | +0 | +100.000% | +
| tests/test_debug.py | +112 | +0 | +0 | +10 | +0 | +100.000% | +
| tests/test_execfile.py | +150 | +1 | +2 | +12 | +2 | +98.148% | +
| tests/test_filereporter.py | +73 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_files.py | +209 | +0 | +0 | +26 | +0 | +100.000% | +
| tests/test_html.py | +556 | +0 | +0 | +28 | +0 | +100.000% | +
| tests/test_json.py | +34 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_misc.py | +99 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/test_mixins.py | +50 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_numbits.py | +98 | +0 | +0 | +10 | +1 | +99.074% | +
| tests/test_oddball.py | +105 | +0 | +62 | +8 | +0 | +100.000% | +
| tests/test_parser.py | +160 | +0 | +0 | +12 | +0 | +100.000% | +
| tests/test_phystokens.py | +119 | +0 | +0 | +12 | +0 | +100.000% | +
| tests/test_plugins.py | +393 | +0 | +15 | +24 | +1 | +99.760% | +
| tests/test_process.py | +628 | +0 | +151 | +26 | +0 | +100.000% | +
| tests/test_python.py | +37 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/test_results.py | +69 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_setup.py | +29 | +0 | +0 | +0 | +0 | +100.000% | +
| tests/test_summary.py | +411 | +0 | +28 | +8 | +0 | +100.000% | +
| tests/test_templite.py | +131 | +0 | +0 | +6 | +0 | +100.000% | +
| tests/test_testing.py | +193 | +0 | +2 | +0 | +0 | +100.000% | +
| tests/test_version.py | +21 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/test_xml.py | +244 | +0 | +3 | +26 | +0 | +100.000% | +
| tests/zipmods.zip/encoded_cp1252.py | +4 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/zipmods.zip/encoded_gb2312.py | +4 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/zipmods.zip/encoded_hebrew.py | +4 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/zipmods.zip/encoded_shift_jis.py | +4 | +0 | +0 | +2 | +0 | +100.000% | +
| tests/zipmods.zip/encoded_utf8.py | +4 | +0 | +0 | +2 | +0 | +100.000% | +
+ No items found using the specified filter. +
+
+
+ Hot-keys on this page
++ r + m + x + p toggle line displays +
++ j + k next/prev highlighted chunk +
++ 0 (zero) top of page +
++ 1 (one) first highlighted chunk +
+