Your IP : 216.73.216.213
B
���W� � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z m
Z
ddl m Z ddl
mZmZ ddlmZ ddlmZ ddlmZmZ dd lmZ dd
lmZmZ dd lm Z m Z m Z dd lm Z m Z dd
l!m"Z" ddl#m$Z$m%Z%m&Z& ddl#m'Z'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7 e(e�Zy ddl8Z8W n e9k
�r� dZ8Y nX G dd� de:�Z;dd� Z<dd � Z=d d � Z>d d � Z?dS )!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 @ sD e Zd ZdZdNdd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� ZdOd*d+�ZdPd,d-�Zd.d/� Zd0d1� ZdQd2d3�Zd4d5� ZdRd6d7�Z d8d9� Z d:d;� Z d<d=� Z d>d?� Z d@dA� Z!dSdBdC�Z"dTdDdE�Z#dUdFdG�Z$dVdHdI�Z%dWdJdK�Z&dLdM� Z'dS )X�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 � | _|rbd}
|dkr d}|dk }|s,d}|| _| j�|�}
|
sb|rRtd| ��| jjddd� tj�d�}|rz|| j_tj�d �}|r�| jj �
|� d
�� | jj ||||t
|�|| |
| | 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.cfgz coverage:)�section_prefixZ
COVERAGE_FILEZCOVERAGE_DEBUG�,)
� data_file� cover_pylib�timid�branch�parallel�source�omit�include�debug� concurrencyN)-r �config� config_file� 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$ rJ r% � auto_datar& r' r/ r) r* r+ r, r- Z did_read_rcZspecified_fileZ
env_data_fileZdebugs� rS �C/opt/alt/python37/lib64/python3.7/site-packages/coverage/control.py�__init__; sb C
zCoverage.__init__c C s | j r
dS | jdkr:tj�d�}|r2t|d�| _ntj| _t| j j
| j�| _
t � | j j
| j | j
�| _
i | _| �� t�� g | _g | _x@| j jp�g D ]0}tj�|�r�| j�t�|�� q�| j�|� q�W t| j j�| _t| j j�| _| j jp�g }d|k�rt | j d� d| j _ t | j | j!| j j"| j j#| j$|d�| _%| j
j&�r�| j%j'�s�| �$dd �(d
d � | j
j&D ��| j%�)� f � x| j
j&D ] }d |_*�q|W | j+�s�| j j �r�t,| j+t-��s�d| _+nd| _+d| _.| j+| _/t0| j
d
�| _1t2| j j3| j$d�| _4t5� | _6| j j7�s�xDt8t9tt:t;t<t=fD ].}|dk �rt>|d��r| j6�?| �@|�� �qW t<�r�t>t<d��s�t<jA}y |jBjC}W n tDk
�r� |jEjC}Y nX | j6�?| �@|�� | �@tF�g| _GtHjI�r�ddlJ}ddlK} x$|| gD ]}
| jG�| �@|
�� �q�W tL�M| j jN� t8�O| jP� d| _ | j�s| j�r.tQ| j�| _RtS| j�| _Tn(| jG�rBtQ| jG�| _U| j6�rVtQ| j6�| _V| j�rjtW| j�| _X| j�r~tW| j�| _Yd } | j
�Zd��r�t[| j j\�]� �} | j
�^d| � d} | j
�Zd��r| j
�^d| �_� � x0| j
D ]&}d|j` }
|�_� }| j
�^|
|� �q�W d} | �r | j
�^dd� dS )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�a�multiprocessing)ZrcfileT)Z should_traceZ
check_includer& r' �warnr- z1Plugin file tracers (%s) aren't supported with %sz, c s s | ] }|j V qd S )N)�_coverage_plugin_name)�.0�pluginrS rS rT � <genexpr> s z!Coverage._init.<locals>.<genexpr>F)r, )�basenamerX �__file__r r. �syszsys: �endrS )arM r7 r1 r2 r3 �openr_ �stderrr r. r, r Z load_pluginsrG rL �_exclude_regex_staler Zset_relative_directoryr) rC �path�exists�append�canonical_filenamer r* r+ r- r r/ r( r �
_should_trace�_check_include_omit_etcr& r' �_warnrF � file_tracersZsupports_plugins�join� tracer_name�_coverage_enabledr9 �
isinstancer rJ rK r rD r
r$ rE �setrH r% �atexit�inspect�platform�re�
_structseq� traceback�hasattr�add�_canonical_dir�
structseq_new� func_code� co_filename�AttributeError�__code__r^ rI r ZTESTING� contracts�sixr Z
set_precisionZ precision�register�_atexitr r: r r; r= r< r
r> r? �should�sorted�__dict__�itemsZwrite_formatted_info�sys_inforY )rQ Zdebug_file_name�srcr- r[ �mrz Zstructseq_filer r� �modZ wrote_anyZ config_info�header�inforS rS rT �_init� s�
zCoverage._initc C s t || �j}tj�|�d S )z<Return the canonical directory of the module or file `morf`.r )r �filenamer1 rd r5 )rQ �morfZ
morf_filenamerS rS rT ry x s zCoverage._canonical_dirc C st |� d�r|S |� d�rV|dd� }tj�|�r4|S tjrR|d }tj�|�rR|S |S |� d�rp|dd� 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)z.pycz.pyoN����wz $py.classi����)�endswithr1 rd re r ZWINDOWS)rQ r� Z py_filenameZ pyw_filenamerS rS rT �_source_for_file} s
zCoverage._source_for_filec C s� |� dd�}t|t�r"|dkr"|S |� dd�}x:dD ]2}t||�r4t||�}nq4t|t�r4|dkr4|S q4W t�|�}|dk r�|S |S dS )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)r3 ro �strrw �getattrrr �
getmodulename)rQ �module_globalsr� Z dunder_name�loader�attrnamer� Z
inspectednamerS rS rT �_name_for_module� s
zCoverage._name_for_modulec C s� |}t | jj|�}dd� }|j�d�}|rb| �|�}|rb|�d�sbtj� |�}|tj� |�krb|}|sp||d�S |�d�r�||d�S |�d�r�||d�S t
� d |�r�||d
�S |� d �r�|d d
� d }t
�|�}||_d } x�| jjD ]�} | js�q�yN| �|�}
|
d k �r>| |
_d|_|
|_|
�� �r,d|_nt
�|
�� �|_P W q� tk
�rv | �d| j � t� � d| _w�Y q�X q�W d|_||_|j�s�|j�s�t d| |j f ��| � |j|�} | �r�||| � |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� rS rS rT �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.classNi����z.pyTz(Disabling plugin %r due to an exception:Fz+Plugin %r didn't set source_filename for %r) �_disposition_initrF Zfile_disposition_class� f_globalsr3 r� �
startswithr1 rd r] rt �searchr� r rg rG rk rn � file_tracerZ_coverage_pluginr� Zhas_dynamic_source_filename�has_dynamic_filename�source_filename� Exceptionrj rY rv � print_excr �original_filename� _check_include_omit_etc_internal) rQ r� �framer� r� r� Z dunder_file�orig� canonicalr[ r� r� rS rS rT �_should_trace_internal� sp
z Coverage._should_trace_internalc C s� | � |j|�}| jrL| j�|�r:|| jkr6| j�|� dS | j�|�s�dS nD| jrd| j�|�s�dS n,| jrz| j�|�rzdS | j r�| j �|�r�dS | j
r�| j
�|�r�dS dS )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� r: r; �matchrC �remover> r< r= r? )rQ r� r� Z
modulenamerS rS rT r� - s$
z)Coverage._check_include_omit_etc_internalc C s, | � ||�}| j�d�r(| 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)rQ r� r� r� rS rS rT rh W s zCoverage._should_tracec C sF | � ||�}| j�d�r@|s(d|f }n d||f }| 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� )rQ r� r� r� �msgrS rS rT ri b s z Coverage._check_include_omit_etcc C s< | j �|� | j�d�r(dt�� |f }tj�d| � dS )zUse `msg` as a warning.�pidz[%d] %szCoverage.py warning: %s
N) rB rf r, r� r1 �getpidr_ rb r� )rQ r� rS rS rT rj r s zCoverage._warnc C s | 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)rQ � option_namerS rS rT r� y s zCoverage.get_optionc C s | j �||� dS )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)rQ r� �valuerS rS rT r� � s zCoverage.set_optionc C s | � � |s| �d� dS )zObsolete method.z(use_cache(False) is no longer supported.N)r� rj )rQ ZusecacherS rS rT � use_cache� s zCoverage.use_cachec C s$ | � � | j�� | j�| j� dS )z;Load previously-collected coverage data from the data file.N)r� rF �resetrE �readrD )rQ rS rS rT �load� s
z
Coverage.loadc C s> | � � | jr| j| _| jr$| �� | j�� d| _d| _dS )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� rK rJ r8 r� rF �startrN rO )rQ rS rS rT r� � s
zCoverage.startc C s | j r| j�� d| _ dS )z Stop measuring code coverage.FN)rN rF �stop)rQ rS rS rT r� � s
z
Coverage.stopc C s | j r| �� | jr | �� dS )z Clean up on process shutdown.N)rN r� r8 �save)rQ rS rS rT r� � s zCoverage._atexitc C s2 | � � | j�� | j�� | jj| jjd� dS )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� rF r� rD �eraserE r. r( )rQ rS rS rT r� � s
zCoverage.erase�excludec C s& | � � t| j|d g � | �� dS )zClear the exclude list.�_listN)r� �setattrr. rc )rQ �whichrS rS rT �
clear_exclude� s zCoverage.clear_excludec C s. | � � t| j|d �}|�|� | �� dS )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. rf rc )rQ Zregexr� � excl_listrS rS rT r� � s
zCoverage.excludec C s | j �� dS )z=Drop all the compiled exclusion regexes, a list was modified.N)rL �clear)rQ rS rS rT rc � s z Coverage._exclude_regex_stalec C s2 || j kr(t| j|d �}t|�| j |< | j | S )z5Return a compiled regex for the given exclusion list.r� )rL r� r. r )rQ r� r� rS rS rT �_exclude_regex� s
zCoverage._exclude_regexc C s | � � 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. )rQ r� rS rS rT �get_exclude_list s zCoverage.get_exclude_listc C s( | � � | �� | jj| j| jd� dS )z2Save the collected coverage data to the data file.)�suffixN)r� �get_datarE r� rD rJ )rQ rS rS rT r� s z
Coverage.savec C sz | � � | �� d}| jjrbt� }x>| jj�� D ].}|d }x |dd� D ]}|�||� qJW q0W | jj| j ||d� dS )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 � )�aliases�
data_paths)
r� r� r. �pathsr �valuesrx rE Zcombine_parallel_datarD )rQ r� r� r� �result�patternrS rS rT �combine s zCoverage.combinec C s | � � | js| jS | j�| j� | jr�xj| jD ]`}|tjkrN| � d| � q0t
tj| d�rrt j �
tj| j�s�| � d| � q0| � d| � q0W | js�| jr�| � d� xJ| jD ]@}x:t|�D ].}t�|�}| jr�| j�|�r�q�| j�|� q�W q�W | jj�r| jj| jjd� d| _| jS )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� rO rD rF Z save_datarA rC r_ �modulesrj rw r1 rd re r^ r@ r) r r rg r? r� Z
touch_filer. r� Z add_run_info)rQ �pkgr� �py_filerS rS rT r� . s0
zCoverage.get_datac C s | � |�\}}}}}||||fS )z:Like `analysis2` but doesn't return excluded line numbers.)� analysis2)rQ r� �f�s�_r� ZmfrS rS rT �analysisc s zCoverage.analysisc C s8 | � � | �|�}|jt|j�t|j�t|j�|�� fS )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)rQ r� r� rS rS rT r� h s
zCoverage.analysis2c C s( | � � t|t�s | �|�}t| j|�S )zTAnalyze a single morf or code unit.
Returns an `Analysis` object.
)r� ro r �_get_file_reporterr rD )rQ �itrS rS rT r� � s
zCoverage._analyzec C st d}d}t |t�r6t|�}| j�|�}|r6| j�|�}|r^|�|�}|dkr^td|j |f ��|dkrpt
|| �}|S )z-Get a FileReporter for a module or file name.N�pythonz1Plugin %r did not provide a file reporter for %r.) ro r r rD r� rG r3 �
file_reporterr rY r )rQ r� r[ r� Zabs_morfZ plugin_namerS rS rT r� � s
zCoverage._get_file_reporterc C sL |s| j �� }t|ttf�s"|g}g }x |D ]}| �|�}|�|� 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.
)rD Zmeasured_filesro �list�tupler� rf )rQ �morfsZfile_reportersr� r� rS rS rT �_get_file_reporters� s
z Coverage._get_file_reportersc C s8 | � � | jj|||||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. r6 r �report) rQ r� r� r� �filer* r+ r� �reporterrS rS rT r� � s
zCoverage.reportc C s8 | � � | jj|||d� t| | j�}|j||d� dS )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. r6 r r� )rQ r� r� r� r* r+ r� rS rS rT �annotate� s
zCoverage.annotatec C s6 | � � | jj||||||d� t| | 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. r6 r r� ) rQ r� r� r� r* r+ r� �titler� rS rS rT � html_report� s zCoverage.html_reportc C s� | � � | jj||||d� d}d}| jjr�| jjdkr@tj}nRtj�| jj�}|rjtj� |�sjt�
|� i } t j r|d| d< t
| jjdf| �}|}z:yt| | j�}
|
j||d�S tk
r� d }� Y nX W d|r�|�� |r�t| jj� X dS )
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. r6 r� r_ �stdoutr1 rd �dirname�isdir�makedirsr �PY3ra r r� r �closer ) rQ r� r� r� r* r+ Z
file_to_closeZ delete_file�
output_dirZ open_kwargsr� rS rS rT �
xml_report s6
zCoverage.xml_reportc
C sV ddl }| �� g }x.| jjD ]"}|j}|js6|d7 }|�|� q W d|jfd|jfd| j fd| j
fd| j � � fd |fd
| j
jfd | j
jfd | jjfd
tj�dd�fdt�� fdt�� fdtjfdt�� fdtjfdtdd� t tj �D ��fdd� t tddg��fg}d d d d d d!g}x:|D ]2}t | |�}|�r:|� � } nd"} |�|| f� �q W |S )#zAReturn a list of (key, value) pairs showing internal information.r Nz (disabled)�version�coveragerI rH Ztracerzplugins.file_tracers� config_filesZ configs_readZ data_pathr� �
� rs �implementation�
executable�cwdrd � environmentc s s( | ] \}}|� d �rd||f V qdS ))ZCOVZPYz%s = %sN)r� )rZ �k�vrS rS rT r\ ] s z$Coverage.sys_info.<locals>.<genexpr>Z command_line� �argvz???r: r; r> r? r= r< z-none-)!r r� rG rk rY rn rf � __version__r^ rI rH rF rm r. Zattempted_config_filesr rE r� r_ r �replacers �python_implementationr r1 �getcwdrd r� r r2 rl r� r� )
rQ ZcovmodZ
ft_pluginsZftZft_namer� Z
matcher_namesZ matcher_nameZmatcherZ matcher_inforS rS rT r� > sJ
zCoverage.sys_info) NNNFNNTNNNNN)r� )r� )r� )N)N)NNNNNNN)NNNNN)NNNNNNN)NNNNN)(r� �
__module__� __qualname__�__doc__rU r� ry r� r� r� r� rh ri rj r� r� r� r� r� r� r� r� r� r� rc r� r� r� r� r� r� r� r� r� r� r� r� r� r r� rS rS rS rT r! - s^
( $l*
5
1r! c C s4 | � }||_ ||_d|_d|_d|_d|_d|_|S )z6Construct and initialize a new FileDisposition object.NFr )r� rg r� r� r� r� r� )�clsr� r� rS rS rT r� y s r� c C s< | j r(d| jf }| jr8|d| j 7 }nd| j| jf }|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� rS rS rT r� � s r� c C sL t j�d�} | sdS ttd�r"dS t| dd�}|t_|�� 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 T)r/ rR F)
r1 r2 r3 rw �process_startupr! r r� r@ rA )ZcpsZcovrS rS rT r � s
r c C s t tdd�} | dk rd| _dS )z7Stop any subprocess auto-measurement from writing data.r NF)r� r r8 )Zauto_created_coveragerS rS rT rP � s rP )@r rq rr r1 rs rt r_ rv 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 ru � ImportError�objectr! r� r� r rP rS rS rS rT �<module> sZ
T
4