Your IP : 216.73.216.213
���W� � @ s] d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m
Z
d d l m Z d d l
m Z m Z d d l m Z d d l m Z d d l m Z m Z d d l m Z d d
l m Z m Z d d l m Z m Z m Z d d l m Z m Z d d
l! m" Z" d d l# m$ Z$ m% Z% m& Z& d d l# m' Z' m( Z( d d l) m* Z* d d l+ m, Z, d d l- m. Z. d d l/ m0 Z0 d d l1 m2 Z2 m3 Z3 d d l4 m5 Z5 d d l6 m7 Z7 e( e � Z y d d l8 Z8 Wn e9 k
rd Z8 Yn XGd d � d e: � Z; d d � Z< d d � Z= d d � Z> d d � Z? d S)!z#Core control stuff for coverage.py.� N)�env�files)�AnnotateReporter)� string_class�iitems)� Collector)�CoverageConfig)� CoverageData�CoverageDataFiles)� DebugControl)� TreeMatcher�FnmatchMatcher)� PathAliases�find_python_files�
prep_patterns)�
ModuleMatcher�abs_file)� HtmlReporter)�CoverageException� bool_or_none�
join_regex)� file_be_gone�isolate_module)�patch_multiprocessing)� FileReporter)�Plugins)�PythonFileReporter)�Analysis�Numbers)�SummaryReporter)� XmlReporterc @ sA e Z d Z d Z d d d d d d d d d d d d d d � Z d d � Z d d
� Z d d � Z d
d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z d d � Z d! d" � Z d# d$ � Z d% d& � Z d' d( � Z d) d* d+ � Z d) d, d- � Z d. d/ � Z d0 d1 � Z d) d2 d3 � Z d4 d5 � Z d d6 d7 � Z d8 d9 � Z d: d; � Z d< d= � Z d> d? � Z d@ dA � Z! d dB dC � Z" d d d d d d d dD dE � Z# d d d d d dF dG � Z$ d d d d d d d dH dI � Z% d d d d d dJ dK � Z& dL dM � Z' d S)N�Coveragez�Programmatic access to coverage.py.
To use::
from coverage import Coverage
cov = Coverage()
cov.start()
#.. call your code ..
cov.stop()
cov.html_report(directory='covhtml')
NFTc
C s? t � | _ | r� d }
| d k r* d } | d k } | sB d } | | _ | j j | � }
|
s� | ry t d | � � | j j d d d �t j j d � } | r� | | j _ t j j d � } | r� | j j j
| j d
� � | j j d | d | d
| d | d t
| � d | d | d |
d | d | �
d | _ | | _ | | _ d | _ d | _ d | _ | _ d | _ | _ d | _ d | _ g | _ d | _ | _ | _ d | _ d | _ | _ | _ d | _! d | _" | _# d | _$ | _% d | _& d | _ d | _' d | _( d | _) t* j+ s;t, � d S)aL
`data_file` is the base name of the data file to use, defaulting to
".coverage". `data_suffix` is appended (with a dot) to `data_file` to
create the final file name. If `data_suffix` is simply True, then a
suffix is created with the machine and process identity included.
`cover_pylib` is a boolean determining whether Python code installed
with the Python interpreter is measured. This includes the Python
standard library and any packages installed with the interpreter.
If `auto_data` is true, then any existing data file will be read when
coverage measurement starts, and data will be saved automatically when
measurement stops.
If `timid` is true, then a slower and simpler trace function will be
used. This is important for some environments where manipulation of
tracing functions breaks the faster trace function.
If `branch` is true, then branch coverage will be measured in addition
to the usual statement coverage.
`config_file` determines what configuration file to read:
* If it is ".coveragerc", it is interpreted as if it were True,
for backward compatibility.
* If it is a string, it is the name of the file to read. If the
file can't be read, it is an error.
* If it is True, then a few standard files names are tried
(".coveragerc", "setup.cfg"). It is not an error for these files
to not be found.
* If it is False, then no configuration file is read.
`source` is a list of file paths or package names. Only code located
in the trees indicated by the file paths or package names will be
measured.
`include` and `omit` are lists of file name patterns. Files that match
`include` will be measured, files that match `omit` will not. Each
will also accept a single string argument.
`debug` is a list of strings indicating what debugging information is
desired.
`concurrency` is a string indicating the concurrency library being used
in the measured code. Without this, coverage.py will get incorrect
results if these libraries are in use. Valid strings are "greenlet",
"eventlet", "gevent", "multiprocessing", or "thread" (the default).
This can also be a list of these strings.
.. versionadded:: 4.0
The `concurrency` parameter.
.. versionadded:: 4.2
The `concurrency` parameter can now be a list of strings.
Fz .coveragercTz#Couldn't read '%s' as a config filez setup.cfg�section_prefixz coverage:Z
COVERAGE_FILEZCOVERAGE_DEBUG�,� data_file� cover_pylib�timid�branch�parallel�source�omit�include�debug� concurrencyN)-r �config� config_fileZ from_filer �os�environ�getr$ r, �extend�split� from_argsr � _debug_file�
_auto_data� _data_suffix� source_match�source_pkgs_match� pylib_match� cover_match�
include_match�
omit_match�
_warn_no_data�_warn_unimported_source� _warningsr* r+ r) � source_pkgs�data�
data_files� collector�plugins�
pylib_dirs�
cover_dirs� data_suffix�
run_suffix� _exclude_re�_inited�_started� _measuredr ZMETACOV� _prevent_sub_process_measurement)�selfr$ rI r% � auto_datar& r' r/ r) r* r+ r, r- Z did_read_rcZspecified_fileZ
env_data_fileZdebugs� rR �C/opt/alt/python35/lib64/python3.5/site-packages/coverage/control.py�__init__; sb C
zCoverage.__init__c
C s� | j r
d S| j d k rU t j j d � } | rI t | d � | _ n t j | _ t | j j
| j � | _
t j | j j
| j | j
� | _
i | _ | j � t j � g | _ g | _ xX | j j p� g D]D } t j j | � r
| j j t j | � � q� | j j | � q� Wt | j j � | _ t | j j � | _ | j j pWg } d | k r�t d | j � d | j _ t d | j d | j! d | j j" d
| j j# d | j$ d | � | _% | j
j& r<| j% j' r<| j$ d
d j( d d � | j
j& D� � | j% j) � f � x | j
j& D] } d | _* q)W| j+ sQ| j j rot, | j+ t- � sxd | _+ n d | _+ d | _. | j+ | _/ t0 d | j
� | _1 t2 d | j j3 d | j$ � | _4 t5 � | _6 | j j7 s�xW t8 t9 t t: t; t< t= f D]: } | d k r�t> | d � r�| j6 j? | j@ | � � q�Wt< r�t> t< d � r�t< jA } y | jB jC } Wn tD k
r�| jE jC } Yn X| j6 j? | j@ | � � | j@ tF � g | _G tH jI rd d lJ } d d lK } x- | | g D] }
| jG j | j@ |
� � q�WtL jM | j jN � t8 jO | jP � d | _ | j sB| j ritQ | j � | _R tS | j � | _T n6 | jG r�tQ | jG � | _U | j6 r�tQ | j6 � | _V | j r�tW | j � | _X | j r�tW | j � | _Y d } | j
jZ d � r t[ | j j\ j] � � } | j
j^ d | � d } | j
jZ d � r�| j
j^ d | j_ � � x= | j
D]2 } d | j` }
| j_ � } | j
j^ |
| � qSWd } | r�| j
j^ d f � d S)z�Set all the initial state.
This is called by the public methods to initialize state. This lets us
construct a :class:`Coverage` object, then tweak its state before this
function is called.
NZCOVERAGE_DEBUG_FILE�aZmultiprocessingZrcfileTZ should_traceZ
check_includer& r' �warnr- z1Plugin file tracers (%s) aren't supported with %sz, c s s | ] } | j Vq d S)N)�_coverage_plugin_name)�.0�pluginrR rR rS � <genexpr> s z!Coverage._init.<locals>.<genexpr>Fr, �basename�__file__r r. �syszsys: �end)arL r6 r0 r1 r2 �openr] �stderrr r. r, r Z load_pluginsrF rK �_exclude_regex_staler Zset_relative_directoryr) rB �path�exists�append�canonical_filenamer r* r+ r- r r/ r( r �
_should_trace�_check_include_omit_etcr& r' �_warnrE � file_tracersZsupports_plugins�join� tracer_name�_coverage_enabledr8 �
isinstancer rI rJ r rC r
r$ rD �setrG r% �atexit�inspect�platform�re�
_structseq� traceback�hasattr�add�_canonical_dir�
structseq_new� func_code� co_filename�AttributeError�__code__r\ rH r ZTESTING� contracts�sixr Z
set_precisionZ precision�register�_atexitr r9 r r: r< r; r
r= r> �should�sorted�__dict__�itemsZwrite_formatted_info�sys_inforW )rP Zdebug_file_name�srcr- rY �mrx Zstructseq_filer} r~ �modZ wrote_anyZ config_info�header�inforR rR rS �_init� s� $
! "
zCoverage._initc C s& t | | � j } t j j | � d S)z<Return the canonical directory of the module or file `morf`.r )r �filenamer0 rb r4 )rP �morfZ
morf_filenamerR rR rS rw x s zCoverage._canonical_dirc C s� | j d � r | S| j d � ru | d d
� } t j j | � rH | St j rq | d } t j j | � rq | S| S| j d � r� | d d � d S| S) z�Return the source file for `filename`.
Given a file name being traced, return the best guess as to the source
file to attribute it to.
z.py�.pyc�.pyoN� �wz $py.class� )r� r� ���i����)�endswithr0 rb rc r ZWINDOWS)rP r� Z py_filenameZ pyw_filenamerR rR rS �_source_for_file} s
zCoverage._source_for_filec C s� | j d d � } t | t � r1 | d k r1 | S| j d d � } xQ d D]I } t | | � rJ t | | � } n qJ t | t � rJ | d k rJ | SqJ Wt j | � } | d k r� | S| Sd S)a� Get the name of the module for a set of globals and file name.
For configurability's sake, we allow __main__ modules to be matched by
their importable name.
If loaded via runpy (aka -m), we can usually recover the "original"
full dotted module name, otherwise, we resort to interpreting the
file name to get the module's name. In the case that the module name
can't be determined, None is returned.
�__name__N�__main__�
__loader__�fullname�name)r� r� )r2 rm �strru �getattrrp �
getmodulename)rP �module_globalsr� Z dunder_name�loader�attrnamer� Z
inspectednamerR rR rS �_name_for_module� s
zCoverage._name_for_modulec C su | } t | j j | � } d d � } | j j d � } | r� | j | � } | r� | j d � r� t j j | � } | t j j | � k r� | } | s� | | d � S| j d � r� | | d � S| j d � r� | | d � St
j d | � r� | | d
� S| j d � r!| d d � d } t
j | � } | | _ d } x� | j j D]� } | j s^qLyk | j | � }
|
d k r�| |
_ d | _ |
| _ |
j � r�d | _ n t
j |
j � � | _ PWqLt k
r| j d | j � t j � d | _ wLYqLXqLWd | _ | | _ | j sq| j sIt d | | j f � � | j | j | � } | rq| | | � | S)a Decide whether to trace execution in `filename`, with a reason.
This function is called from the trace function. As each new file name
is encountered, this function determines whether it is traced or not.
Returns a FileDisposition object.
c S s d | _ | | _ | S)z+Simple helper to make it easy to return NO.F)�trace�reason)�dispr� rR rR rS �nope� s z-Coverage._should_trace_internal.<locals>.noper\ �<z empty string isn't a file namezmemory:zmemory isn't traceableznot a real file namez[/\\]Modules[/\\]pyexpat.czpyexpat lies about itselfz $py.classNr� z.pyTz(Disabling plugin %r due to an exception:Fz+Plugin %r didn't set source_filename for %ri����) �_disposition_initrE Zfile_disposition_class� f_globalsr2 r� �
startswithr0 rb r[ rr �searchr� r re rF ri rl � file_tracerZ_coverage_pluginr� Zhas_dynamic_source_filename�has_dynamic_filename�source_filename� Exceptionrh rW rt � print_excr �original_filename� _check_include_omit_etc_internal) rP r� �framer� r� r� Z dunder_file�orig� canonicalrY r� r� rR rR rS �_should_trace_internal� sp
z Coverage._should_trace_internalc C s� | j | j | � } | j rl | j j | � rS | | j k rO | j j | � d S| j j | � s� d Sn` | j r� | j j | � s� d Sn> | j r� | j j | � r� d S| j r� | j j | � r� d S| j
r� | j
j | � r� d Sd S)z�Check a file name against the include, omit, etc, rules.
Returns a string or None. String means, don't trace, and is the reason
why. None means no reason found to not trace.
Nz falls outside the --source treesz!falls outside the --include treeszis in the stdlibzis part of coverage.pyzis inside an --omit pattern) r� r� r9 r: �matchrB �remover= r; r< r> )rP r� r� Z
modulenamerR rR rS r� - s$ z)Coverage._check_include_omit_etc_internalc C s> | j | | � } | j j d � r: | j j t | � � | S)z�Decide whether to trace execution in `filename`.
Calls `_should_trace_internal`, and returns the FileDisposition.
r� )r� r, r� �write�_disposition_debug_msg)rP r� r� r� rR rR rS rf W s zCoverage._should_tracec C s_ | j | | � } | j j d � rZ | s: d | f } n d | | f } | j j | � | S)z�Check a file name against the include/omit/etc, rules, verbosely.
Returns a boolean: True if the file should be traced, False if not.
r� z Including %rzNot including %r: %s)r� r, r� r� )rP r� r� r� �msgrR rR rS rg b s z Coverage._check_include_omit_etcc C sP | j j | � | j j d � r8 d t j � | f } t j j d | � d S)zUse `msg` as a warning.�pidz[%d] %szCoverage.py warning: %s
N) rA rd r, r� r0 �getpidr] r` r� )rP r� rR rR rS rh r s zCoverage._warnc C s | j j | � S)a[ Get an option from the configuration.
`option_name` is a colon-separated string indicating the section and
option name. For example, the ``branch`` option in the ``[run]``
section of the config file would be indicated with `"run:branch"`.
Returns the value of the option.
.. versionadded:: 4.0
)r. �
get_option)rP � option_namerR rR rS r� y s zCoverage.get_optionc C s | j j | | � d S)a� Set an option in the configuration.
`option_name` is a colon-separated string indicating the section and
option name. For example, the ``branch`` option in the ``[run]``
section of the config file would be indicated with ``"run:branch"``.
`value` is the new value for the option. This should be a Python
value where appropriate. For example, use True for booleans, not the
string ``"True"``.
As an example, calling::
cov.set_option("run:branch", True)
has the same effect as this configuration file::
[run]
branch = True
.. versionadded:: 4.0
N)r. �
set_option)rP r� �valuerR rR rS r� � s zCoverage.set_optionc C s! | j � | s | j d � d S)zObsolete method.z(use_cache(False) is no longer supported.N)r� rh )rP ZusecacherR rR rS � use_cache� s
zCoverage.use_cachec C s. | j � | j j � | j j | j � d S)z;Load previously-collected coverage data from the data file.N)r� rE �resetrD �readrC )rP rR rR rS �load� s
z
Coverage.loadc C sU | j � | j r | j | _ | j r2 | j � | j j � d | _ d | _ d S)ae Start measuring code coverage.
Coverage measurement actually occurs in functions called after
:meth:`start` is invoked. Statements in the same scope as
:meth:`start` won't be measured.
Once you invoke :meth:`start`, you must also call :meth:`stop`
eventually, or your process might not shut down cleanly.
TN) r� rJ rI r7 r� rE �startrM rN )rP rR rR rS r� � s
zCoverage.startc C s# | j r | j j � d | _ d S)z Stop measuring code coverage.FN)rM rE �stop)rP rR rR rS r� � s
z
Coverage.stopc C s* | j r | j � | j r& | j � d S)z Clean up on process shutdown.N)rM r� r7 �save)rP rR rR rS r� � s
zCoverage._atexitc C sA | j � | j j � | j j � | j j d | j j � d S)z�Erase previously-collected coverage data.
This removes the in-memory data collected in this session as well as
discarding the data file.
r( N)r� rE r� rC �eraserD r. r( )rP rR rR rS r� � s
zCoverage.erase�excludec C s/ | j � t | j | d g � | j � d S)zClear the exclude list.�_listN)r� �setattrr. ra )rP �whichrR rR rS �
clear_exclude� s
zCoverage.clear_excludec C s; | j � t | j | d � } | j | � | j � d S)a| Exclude source lines from execution consideration.
A number of lists of regular expressions are maintained. Each list
selects lines that are treated differently during reporting.
`which` determines which list is modified. The "exclude" list selects
lines that are not considered executable at all. The "partial" list
indicates lines with branches that are not taken.
`regex` is a regular expression. The regex is added to the specified
list. If any of the regexes in the list is found in a line, the line
is marked for special treatment during reporting.
r� N)r� r� r. rd ra )rP Zregexr� � excl_listrR rR rS r� � s
zCoverage.excludec C s | j j � d S)z=Drop all the compiled exclusion regexes, a list was modified.N)rK �clear)rP rR rR rS ra � s z Coverage._exclude_regex_stalec C sC | | j k r8 t | j | d � } t | � | j | <| j | S)z5Return a compiled regex for the given exclusion list.r� )rK r� r. r )rP r� r� rR rR rS �_exclude_regex� s zCoverage._exclude_regexc C s | j � t | j | d � S)z�Return a list of excluded regex patterns.
`which` indicates which list is desired. See :meth:`exclude` for the
lists that are available, and their meaning.
r� )r� r� r. )rP r� rR rR rS �get_exclude_list s
zCoverage.get_exclude_listc C s4 | j � | j � | j j | j d | j �d S)z2Save the collected coverage data to the data file.�suffixN)r� �get_datarD r� rC rI )rP rR rR rS r� s
z
Coverage.savec C s� | j � | j � d } | j j r� t � } xO | j j j � D]; } | d } x( | d d � D] } | j | | � qc WqB W| j j | j d | d | �d S)aR Combine together a number of similarly-named coverage data files.
All coverage data files whose name starts with `data_file` (from the
coverage() constructor) will be read, and combined together into the
current measurements.
`data_paths` is a list of files or directories from which data should
be combined. If no list is passed, then the data files from the
directory indicated by the current data file (probably the current
directory) will be combined.
.. versionadded:: 4.0
The `data_paths` parameter.
Nr r� �aliases�
data_paths)
r� r� r. �pathsr �valuesrv rD Zcombine_parallel_datarC )rP r� r� r� �result�patternrR rR rS �combine s
zCoverage.combinec C s� | j � | j s | j S| j j | j � | j r� x� | j D]� } | t j k ri | j d | � q@ t
t j | d � o� t j j
t j | j � s� | j d | � q@ | j d | � q@ W| j r� | j r� | j d � xe | j D]Z } xQ t | � D]C } t j | � } | j r4| j j | � r4q| j j | � qWq� W| j j rq| j j d | j j � d | _ | j S)z�Get the collected data and reset the collector.
Also warn about various problems collecting data.
Returns a :class:`coverage.CoverageData`, the collected coverage data.
.. versionadded:: 4.0
z Module %s was never imported.r\ z Module %s has no Python source.z4Module %s was previously imported, but not measured.zNo data was collected.�noteF)r� rN rC rE Z save_datar@ rB r] �modulesrh ru r0 rb rc r\ r? r) r r re r> r� Z
touch_filer. r� Z add_run_info)rP �pkgr� �py_filerR rR rS r� . s0
zCoverage.get_datac C s. | j | � \ } } } } } | | | | f S)z:Like `analysis2` but doesn't return excluded line numbers.)� analysis2)rP r� �f�s�_r� ZmfrR rR rS �analysisc s zCoverage.analysisc C sP | j � | j | � } | j t | j � t | j � t | j � | j � f S)aG Analyze a module.
`morf` is a module or a file name. It will be analyzed to determine
its coverage statistics. The return value is a 5-tuple:
* The file name for the module.
* A list of line numbers of executable statements.
* A list of line numbers of excluded statements.
* A list of line numbers of statements not run (missing from
execution).
* A readable formatted string of the missing line numbers.
The analysis uses the source file itself and the current measured
coverage data.
)r� �_analyzer� r� Z
statementsZexcluded�missingZmissing_formatted)rP r� r� rR rR rS r� h s
zCoverage.analysis2c C s8 | j � t | t � s( | j | � } t | j | � S)zTAnalyze a single morf or code unit.
Returns an `Analysis` object.
)r� rm r �_get_file_reporterr rC )rP �itrR rR rS r� � s
zCoverage._analyzec C s� d } d } t | t � rQ t | � } | j j | � } | rQ | j j | � } | r� | j | � } | d k r� t d | j | f � � | d k r� t
| | � } | S)z-Get a FileReporter for a module or file name.N�pythonz1Plugin %r did not provide a file reporter for %r.) rm r r rC r� rF r2 �
file_reporterr rW r )rP r� rY r� Zabs_morfZ plugin_namerR rR rS r� � s zCoverage._get_file_reporterc C sj | s | j j � } t | t t f � s3 | g } g } x* | D]" } | j | � } | j | � q@ W| S)a� Get a list of FileReporters for a list of modules or file names.
For each module or file name in `morfs`, find a FileReporter. Return
the list of FileReporters.
If `morfs` is a single module or file name, this returns a list of one
FileReporter. If `morfs` is empty or None, then the list of all files
measured is used to find the FileReporters.
)rC Zmeasured_filesrm �list�tupler� rd )rP �morfsZfile_reportersr� r� rR rR rS �_get_file_reporters� s
z Coverage._get_file_reportersc C sZ | j � | j j d | d | d | d | d | � t | | j � } | j | d | �S)a� Write a summary report to `file`.
Each module in `morfs` is listed, with counts of statements, executed
statements, missing statements, and a list of lines missed.
`include` is a list of file name patterns. Files that match will be
included in the report. Files matching `omit` will not be included in
the report.
Returns a float, the total percentage covered.
�
ignore_errorsr* r+ � show_missing� skip_covered�outfile)r� r. r5 r �report) rP r� r� r� �filer* r+ r� �reporterrR rR rS r� � s
zCoverage.reportc C sR | j � | j j d | d | d | � t | | j � } | j | d | �d S)az Annotate a list of modules.
Each module in `morfs` is annotated. The source is written to a new
file, named with a ",cover" suffix, with each line prefixed with a
marker to indicate the coverage of the line. Covered lines have ">",
excluded lines have "-", and missing lines have "!".
See :meth:`report` for other arguments.
r� r* r+ � directoryN)r� r. r5 r r� )rP r� r� r� r* r+ r� rR rR rS �annotate� s
zCoverage.annotatec
C sZ | j � | j j d | d | d | d | d | d | � t | | j � } | j | � S)a Generate an HTML report.
The HTML is written to `directory`. The file "index.html" is the
overview starting point, with links to more detailed pages for
individual modules.
`extra_css` is a path to a file of other CSS to apply on the page.
It will be copied into the HTML directory.
`title` is a text string (not HTML) to use as the title of the HTML
report.
See :meth:`report` for other arguments.
Returns a float, the total percentage covered.
r� r* r+ Zhtml_dir� extra_cssZ
html_title)r� r. r5 r r� ) rP r� r� r� r* r+ r� �titler� rR rR rS � html_report� s
zCoverage.html_reportc C sS | j � | j j d | d | d | d | � d } d } | j j r� | j j d k re t j } nu t j j | j j � } | r� t j j | � r� t j
| � i } t j r� d | d <t
| j j d
| � } | } zK y) t | | j � }
|
j | d | �SWn t k
r#d } � Yn XWd | rN| j � | rNt | j j � Xd S)
ab Generate an XML report of coverage results.
The report is compatible with Cobertura reports.
Each module in `morfs` is included in the report. `outfile` is the
path to write the file to, "-" will write to stdout.
See :meth:`report` for other arguments.
Returns a float, the total percentage covered.
r� r* r+ �
xml_outputNF�-�utf8�encodingr� r� T)r� r. r5 r� r] �stdoutr0 rb �dirname�isdir�makedirsr �PY3r_ r r� r �closer ) rP r� r� r� r* r+ Z
file_to_closeZ delete_file�
output_dirZ open_kwargsr� rR rR rS �
xml_report s6
zCoverage.xml_reportc
C s� d d l } | j � g } x= | j j D]/ } | j } | j sK | d 7} | j | � q) Wd | j f d | j f d | j f d | j
f d | j j � f d | f d
| j
j f d | j
j f d | j j f d
t j j d d � f d t j � f d t j � f d t j f d t j � f d t j f d t d d � t t j � D� � f d d j t t d d g � � f g } d d d d d d! g } xK | D]C } t | | � } | r�| j � } n d" } | j | | f � q�W| S)#zAReturn a list of (key, value) pairs showing internal information.r Nz (disabled)�version�coveragerH rG Ztracerzplugins.file_tracers� config_filesZ configs_readZ data_pathr� �
� rq �implementation�
executable�cwdrb � environmentc s s4 | ]* \ } } | j d � r d | | f Vq d S)�COV�PYz%s = %sN)r r )r� )rX �k�vrR rR rS rZ ] s z$Coverage.sys_info.<locals>.<genexpr>Z command_line� �argvz???r9 r: r= r> r< r; z-none-)!r r� rF ri rW rl rd � __version__r\ rH rG rE rk r. Zattempted_config_filesr rD r� r] r �replacerq �python_implementationr r0 �getcwdrb r� r r1 rj r� r� )
rP ZcovmodZ
ft_pluginsZftZft_namer� Z
matcher_namesZ matcher_nameZmatcherZ matcher_inforR rR rS r� > sJ
'
zCoverage.sys_info)(r� �
__module__� __qualname__�__doc__rT r� rw r� r� r� r� rf rg rh r� r� r� r� r� r� r� r� r� r� ra r� r� r� r� r� r� r� r� r� r� r� r� r� r r� rR rR rR rS r! - sZ
� � $ l *
5 1r! c C sL | � } | | _ | | _ d | _ d | _ d | _ d | _ d | _ | S)z6Construct and initialize a new FileDisposition object.NFr
)r� re r� r� r� r� r� )�clsr� r� rR rR rS r� y s r� c C sP | j r6 d | j f } | j rL | d | j 7} n d | j | j f } | S)z?Make a nice debug message of what the FileDisposition is doing.z
Tracing %rz: will be traced by %rzNot tracing %r: %s)r� r� r� r� )r� r� rR rR rS r� � s r� c C sm t j j d � } | s d St t d � r/ d St d | d d � } | t _ | j � d | _ d | _ | S)a� Call this at Python start-up to perhaps measure coverage.
If the environment variable COVERAGE_PROCESS_START is defined, coverage
measurement is started. The value of the variable is the config file
to use.
There are two ways to configure your Python installation to invoke this
function when Python starts:
#. Create or append to sitecustomize.py to add these lines::
import coverage
coverage.process_startup()
#. Create a .pth file in your Python installation containing::
import coverage; coverage.process_startup()
Returns the :class:`Coverage` instance that was started, or None if it was
not started by this call.
ZCOVERAGE_PROCESS_STARTNr r/ rQ TF)
r0 r1 r2 ru �process_startupr! r r� r? r@ )ZcpsZcovrR rR rS r � s
r c C s+ t t d d � } | d k r' d | _ d S)z7Stop any subprocess auto-measurement from writing data.r NF)r� r r7 )Zauto_created_coveragerR rR rS rO � s rO )@r ro rp r0 rq rr r] rt r r r Zcoverage.annotater Zcoverage.backwardr r Zcoverage.collectorr Zcoverage.configr Z
coverage.datar r
Zcoverage.debugr Zcoverage.filesr r
r r r r r Z
coverage.htmlr Z
coverage.miscr r r r r Zcoverage.multiprocr Zcoverage.pluginr Zcoverage.plugin_supportr Zcoverage.pythonr Zcoverage.resultsr r Zcoverage.summaryr Zcoverage.xmlreportr rs � ImportError�objectr! r� r� r rO rR rR rR rS �<module> sR
� � � � P
4