Your IP : 216.73.216.213
N^�W�k � @ sc 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 Z d d l 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 m Z e e � Z Gd d � d e � Z Gd
d � d e � Z d d
� Z d d � Z d d � Z e d k r_d d l Z e e j d d � � d S)z Coverage data for coverage.py.� N)�env)�iitems� string_class)�_TEST_NAME_FILE)� PathAliases)�CoverageException� file_be_gone�isolate_modulec @ s� e Z d Z d Z 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 d � Z d d � Z
e
Z d d � Z d d � Z d Z e d d � � Z e d d � � Z e d! d" � � Z d# d$ � Z d% d& � Z d' d( � Z d) d* � Z d+ d, � Z d- d. � Z d/ d0 � Z d1 d2 � Z d d3 d4 � Z d5 d6 � Z d7 d8 � Z d9 d: � Z! d; d< � Z" d= d> � Z# d S)?� CoverageDataa�
Manages collected coverage data, including file storage.
This class is the public supported API to the data coverage.py collects
during program execution. It includes information about what code was
executed. It does not include information from the analysis phase, to
determine what lines could have been executed, or what lines were not
executed.
.. note::
The file format is not documented or guaranteed. It will change in
the future, in possibly complicated ways. Do not read coverage.py
data files directly. Use this API to avoid disruption.
There are a number of kinds of data that can be collected:
* **lines**: the line numbers of source lines that were executed.
These are always available.
* **arcs**: pairs of source and destination line numbers for transitions
between source lines. These are only available if branch coverage was
used.
* **file tracer names**: the module names of the file tracer plugins that
handled each file in the data.
* **run information**: information about the program execution. This is
written during "coverage run", and then accumulated during "coverage
combine".
Lines, arcs, and file tracer names are stored for each source file. File
names in this API are case-sensitive, even on platforms with
case-insensitive file systems.
To read a coverage.py data file, use :meth:`read_file`, or
:meth:`read_fileobj` if you have an already-opened file. You can then
access the line, arc, or file tracer data with :meth:`lines`, :meth:`arcs`,
or :meth:`file_tracer`. Run information is available with
:meth:`run_infos`.
The :meth:`has_arcs` method indicates whether arc data is available. You
can get a list of the files in the data with :meth:`measured_files`.
A summary of the line data is available from :meth:`line_counts`. As with
most Python containers, you can determine if there is any data at all by
using this object as a boolean value.
Most data files will be created by coverage.py itself, but you can use
methods here to create data files if you like. The :meth:`add_lines`,
:meth:`add_arcs`, and :meth:`add_file_tracers` methods add data, in ways
that are convenient for coverage.py. The :meth:`add_run_info` method adds
key-value pairs to the run information.
To add a file without any measured data, use :meth:`touch_file`.
You write to a named file with :meth:`write_file`, or to an already opened
file with :meth:`write_fileobj`.
You can clear the data in memory with :meth:`erase`. Two data collections
can be combined by using :meth:`update` on one :class:`CoverageData`,
passing it the other.
Nc C s1 | | _ d | _ d | _ i | _ g | _ d S)zhCreate a CoverageData.
`debug` is a `DebugControl` object for writing debug messages.
N)�_debug�_lines�_arcs�
_file_tracers�_runs)�self�debug� r �@/opt/alt/python35/lib64/python3.5/site-packages/coverage/data.py�__init__s s
zCoverageData.__init__c
C s� d j d | j j d | j d k r* d n d j t | j � � d | j d k rW d n d j t | j � � d d j t | j � � d d j t | j � � � S)
NzA<{klass} lines={lines} arcs={arcs} tracers={tracers} runs={runs}>�klass�lines�Nonez{{{0}}}�arcsZtracers�runsz[{0}])�format� __class__�__name__r �lenr
r r )r r r r �__repr__� s --zCoverageData.__repr__c C s
| j � S)z�Does this data have arcs?
Arc data is only available if branch coverage was used during
collection.
Returns a boolean.
)� _has_arcs)r r r r �has_arcs� s zCoverageData.has_arcsc C s� | j d k r_ | j j | � } | d k r~ t j j | � } t t d d � | D� � � Sn | j d k r~ | j j | � Sd S)ac Get the list of lines executed for a file.
If the file was not measured, returns None. A file might be measured,
and have no lines executed, in which case an empty list is returned.
If the file was executed, returns a list of integers, the line numbers
executed in the file. The list is in no particular order.
Nc s s! | ] } | d k r | Vq d S)r Nr )�.0�lr r r � <genexpr>� s z%CoverageData.lines.<locals>.<genexpr>)r
�get� itertools�chain�
from_iterable�list�setr )r �filenamer Z all_linesr r r r � s
zCoverageData.linesc C s- | j d k r) | | j k r) | j | Sd S)a� Get the list of arcs executed for a file.
If the file was not measured, returns None. A file might be measured,
and have no arcs executed, in which case an empty list is returned.
If the file was executed, returns a list of 2-tuples of integers. Each
pair is a starting line number and an ending line number for a
transition from one line to another. The list is in no particular
order.
Negative numbers have special meaning. If the starting line number is
-N, it represents an entry to the code object that starts at line N.
If the ending ling number is -N, it's an exit from the code object that
starts at line N.
N)r
)r r* r r r r � s zCoverageData.arcsc C s5 | | j p | j p i k r1 | j j | d � Sd S)a Get the plugin name of the file tracer for a file.
Returns the name of the plugin that handles this file. If the file was
measured, but didn't use a plugin, then "" is returned. If the file
was not measured, then None is returned.
� N)r
r r r$ )r r* r r r � file_tracer� s zCoverageData.file_tracerc C s | j S)z�Return the list of dicts of run information.
For data collected during a single run, this will be a one-element
list. If data has been combined, there will be one element for each
original data file.
)r )r r r r � run_infos� s zCoverageData.run_infosc C s t | j p | j p i � S)z+A list of all files that had been measured.)r( r
r )r r r r �measured_files� s zCoverageData.measured_filesFc C sa i } | r d d � } n t j j } x3 | j � D]% } t | j | � � | | | � <q4 W| S)a\ Return a dict summarizing the line coverage data.
Keys are based on the file names, and values are the number of executed
lines. If `fullpath` is true, then the keys are the full pathnames of
the files, otherwise they are the basenames of the files.
Returns a dict mapping file names to counts of lines.
c S s | S)Nr )�fr r r �<lambda>� s z*CoverageData.line_counts.<locals>.<lambda>)�os�path�basenamer. r r )r �fullpathZsummZ filename_fnr* r r r � line_counts� s
#zCoverageData.line_countsc C s t | j p | j � S)N)�boolr r
)r r r r � __nonzero__ s zCoverageData.__nonzero__c C s� | j | � } d | _ | _ d | k r8 | d | _ d | k rj t d d � t | d � D� � | _ | j d i � | _ | j d g � | _ | j � d S)zzRead the coverage data from the given file object.
Should only be used on an empty CoverageData object.
Nr r c s s. | ]$ \ } } | d d � | D� f Vq d S)c S s g | ] } t | � � q Sr )�tuple)r! �pairr r r �
<listcomp> s z7CoverageData.read_fileobj.<locals>.<genexpr>.<listcomp>Nr )r! �fnamer r r r r# s z,CoverageData.read_fileobj.<locals>.<genexpr>� file_tracersr ) �_read_raw_datar r
�dictr r$ r r � _validate)r �file_obj�datar r r � read_fileobj s
zCoverageData.read_fileobjc C s� | j r2 | j j d � r2 | j j d | f � y* | j | � � } | j | � Wd QRXWnD t k
r� } z$ t d | | j j | f � � WYd d } ~ Xn Xd S)z8Read the coverage data from `filename` into this object.�dataiozReading data from %rNz$Couldn't read data from '%s': %s: %s) r �should�write�_open_for_readingrB � Exceptionr r r )r r* r/ �excr r r � read_file s zCoverageData.read_filez?!coverage.py: This is a private format, don't read it directly!c C s
t | d � S)z+Open a file appropriately for reading data.�r)�open)�clsr* r r r rF / s z CoverageData._open_for_readingc C s@ | j t | j � � } | | j k r3 t d � � t j | � S)z%Read the raw data from a file object.z*Doesn't seem to be a coverage.py data file)�readr �_GO_AWAYr �json�load)rL r@ Zgo_awayr r r r= 4 s zCoverageData._read_raw_datac C s* | j | � � } | j | � SWd QRXd S)z-Read the raw data from a file, for debugging.N)rF r= )rL r* r/ r r r �_read_raw_data_file< s z CoverageData._read_raw_data_filec C s� | j rT | j j d � rT | j j d t | � t d d � | j � D� � f � | j � rl t d � � | j d k r� i | _ xb t | � D]T \ } } | | j k r� t
| j | � } | j | � | } t | � | j | <q� W| j
� d S)z�Add measured line data.
`line_data` is a dictionary mapping file names to dictionaries::
{ filename: { lineno: None, ... }, ...}
�dataopz&Adding lines: %d files, %d lines totalc s s | ] } t | � Vq d S)N)r )r! r r r r r# P s z)CoverageData.add_lines.<locals>.<genexpr>z$Can't add lines to existing arc dataN)r rD rE r �sum�valuesr r r r r) �updater( r? )r Z line_datar* ZlinenosZ new_linenosr r r � add_linesF s -
zCoverageData.add_linesc C s� | j rT | j j d � rT | j j d t | � t d d � | j � D� � f � | j � rl t d � � | j d k r� i | _ xb t | � D]T \ } } | | j k r� t
| j | � } | j | � | } t | � | j | <q� W| j
� d S)z�Add measured arc data.
`arc_data` is a dictionary mapping file names to dictionaries::
{ filename: { (l1,l2): None, ... }, ...}
rR z$Adding arcs: %d files, %d arcs totalc s s | ] } t | � Vq d S)N)r )r! r r r r r# j s z(CoverageData.add_arcs.<locals>.<genexpr>z$Can't add arcs to existing line dataN)r rD rE r rS rT �
_has_linesr r
r r) rU r( r? )r Zarc_datar* r Znew_arcsr r r �add_arcs` s -
zCoverageData.add_arcsc C s� | j r8 | j j d � r8 | j j d t | � f � | j pM | j pM i } x� t | � D]{ \ } } | | k r� t d | f � � | j j | � } | d k r� | | k r� t d | | | f � � | | j | <q] W| j
� d S)zdAdd per-file plugin information.
`file_tracers` is { filename: plugin_name, ... }
rR z Adding file tracers: %d filesz3Can't add file tracer data for unmeasured file '%s'Nz/Conflicting file tracer name for '%s': %r vs %r) r rD rE r r
r r r r r$ r? )r r< Zexisting_filesr* Z plugin_nameZexisting_pluginr r r �add_file_tracersz s z CoverageData.add_file_tracersc K si | j r2 | j j d � r2 | j j d | f � | j sG i g | _ | j d j | � | j � d S)z�Add information about the run.
Keywords are arbitrary, and are stored in the run dictionary. Values
must be JSON serializable. You may use this function more than once,
but repeated keywords overwrite each other.
rR zAdding run info: %rr N)r rD rE r rU r? )r �kwargsr r r � add_run_info� s zCoverageData.add_run_infoc C s� | j r2 | j j d � r2 | j j d | f � | j � rX | j � rX t d � � | j � rp | j } n | j } | j | g � | j � d S)z<Ensure that `filename` appears in the data, empty if needed.rR z Touching %rz*Can't touch files in an empty CoverageDataN)
r rD rE r rW r r
r �
setdefaultr? )r r* �wherer r r �
touch_file� s zCoverageData.touch_filec C s� i } | j � r | j | d <| j � r8 | j | d <| j rN | j | d <| j rd | j | d <| j | j � t j | | � d S)z&Write the coverage data to `file_obj`.r r r< r N)
r r
rW r r r rE rN rO �dump)r r@ Z file_datar r r �
write_fileobj� s
zCoverageData.write_fileobjc C s\ | j r2 | j j d � r2 | j j d | f � t | d � � } | j | � Wd QRXd S)z&Write the coverage data to `filename`.rC zWriting data to %r�wN)r rD rE rK r` )r r* Zfdatar r r �
write_file� s zCoverageData.write_filec C s2 d | _ d | _ i | _ g | _ | j � d S)z Erase the data in this object.N)r r
r r r? )r r r r �erase� s
zCoverageData.erasec
C s9 | j � r$ | j � r$ t d � � | j � rH | j � rH t d � � | pT t � } x� | j � D]z } | j | � } | j | � } | j | � } | d k r� | r� | | j | <qd | | k rd t d | | | f � � qd W| j j | j � | j � r�| j
d k ri | _
xt t | j
� D]c \ } } | j | � } | | j
k rt | j
| � } | j
| � t | � } | | j
| <q)W| j � r+| j d k r�i | _ xt t | j � D]c \ } } | j | � } | | j k rt | j | � } | j
| � t | � } | | j | <q�W| j � d S)z�Update this data with data from another `CoverageData`.
If `aliases` is provided, it's a `PathAliases` object that is used to
re-map paths to match the local machine's.
z%Can't combine arc data with line dataz%Can't combine line data with arc dataNz/Conflicting file tracer name for '%s': %r vs %r)rW r r r r. r, �mapr r �extendr r r) rU r( r
r? )
r Z
other_data�aliasesr* Z other_pluginZ this_pluginZ
file_linesr Z file_arcsr r r r rU � sL
zCoverageData.updatec C s t j r | j � d S)z>If we are in paranoid mode, validate that everything is right.N)r ZTESTING�_validate_invariants)r r r r r? s zCoverageData._validatec C s� | j � o | j � s% t d � � | j � r� xn t | j � D]] \ } } t | t � so t d | f � � t d d � | D� � sA t d | | f � � qA W| j � r xn t | j � D]] \ } } t | t � s� t d | f � � t d d � | D� � s� t d | | f � � q� Wxj t | j � D]Y \ } } t | t � s]t d | f � � | rrt | t � s/t d
| | f � � q/WxY | j
D]N } t | t � s�t � x0 | D]( } t | t � s�t d | f � � q�Wq�Wd S)
z Validate internal invariants.z$Shouldn't have both _lines and _arcsz Key in _lines shouldn't be %rc s s | ] } t | t � Vq d S)N)�
isinstance�int)r! �xr r r r# ' s z4CoverageData._validate_invariants.<locals>.<genexpr>z_lines[%r] shouldn't be %rz Key in _arcs shouldn't be %rc s s3 | ]) \ } } t | t � o* t | t � Vq d S)N)rh ri )r! rj �yr r r r# / s z_arcs[%r] shouldn't be %rz$Key in _file_tracers shouldn't be %rz _file_tracers[%r] shoudn't be %rz Key in _runs shouldn't be %rN) rW r �AssertionErrorr r rh r �allr
r r r> )r r; r r Zplugin�val�keyr r r rg s* " "
z!CoverageData._validate_invariantsc C sm | j � r1 | j t | j | � p' g � � n" | j t | j | � pL g � � | j | j | � � d S)z�Contribute `filename`'s data to the `hasher`.
`hasher` is a `coverage.misc.Hasher` instance to be updated with
the file's data. It should only get the results data, not the run
data.
N)r rU �sortedr r r, )r r* Zhasherr r r � add_to_hashB s %"zCoverageData.add_to_hashc C s
| j d k S)z Do we have data in self._lines?N)r )r r r r rW T s zCoverageData._has_linesc C s
| j d k S)z Do we have data in self._arcs?N)r
)r r r r r X s zCoverageData._has_arcs)$r �
__module__� __qualname__�__doc__r r r r r r, r- r. r5 r7 �__bool__rB rI rN � classmethodrF r= rQ rV rX rY r[ r^ r` rb rc rU r? rg rq rW r r r r r r
s@ ?
@ & r
c @ sd e Z d Z d Z d d d d � Z d d d � Z d d � Z d d
d � Z d d d d
� Z d S)�CoverageDataFilesz&Manage the use of coverage data files.Nc C s( | | _ t j j | p d � | _ d S)z�Create a CoverageDataFiles to manage data files.
`warn` is the warning function to use.
`basename` is the name of the file to use for storing data.
z .coverageN)�warnr1 r2 �abspathr* )r r3 rx r r r r ` s zCoverageDataFiles.__init__Fc C s� t | j � | r} t j j | j � \ } } | d } t j j t j j | � | � } x! t j | � D] } t | � qi Wd S)z�Erase the data from the file storage.
If `parallel` is true, then also deletes data files created from the
basename by parallel-mode.
z.*N)r r* r1 r2 �split�joinry �glob)r �parallel�data_dir�local�localdot�patternr* r r r rc l s
!zCoverageDataFiles.erasec C s) t j j | j � r% | j | j � d S)zRead the coverage data.N)r1 r2 �existsr* rI )r rA r r r rM { s zCoverageDataFiles.readc C s� | j } | d k r{ d } t rM t t � � } | j � } Wd QRXd | } d t j � | t j � t j d d � f } | r� | d | 7} | j
| � d S)a7 Write the collected coverage data to a file.
`suffix` is a suffix to append to the base file name. This can be used
for multiple or parallel execution, so that many coverage data files
can exist simultaneously. A dot will be used to join the base name and
the suffix.
Tr+ N�.z %s%s.%s.%06dr i?B ) r* r rK rM �socket� gethostnamer1 �getpid�random�randintrb )r rA �suffixr* �extrar/ Z test_namer r r rE � s
zCoverageDataFiles.writec
C sh t j j | j � \ } } | d } | p1 | g } g } x� | D]� } t j j | � ru | j t j j | � � qA t j j | � r� t j j t j j | � | � } | j t
j
| � � qA t d | f � � qA Wx� | D]� }
t � } y | j
|
� WnA t k
rB} z! | j r0| j t | � � WYd d } ~ Xq� X| j | d | �t |
� q� Wd S)ab Combine a number of data files together.
Treat `self.filename` as a file prefix, and combine the data from all
of the data files starting with that prefix plus a dot.
If `aliases` is provided, it's a `PathAliases` object that is used to
re-map paths to match the local machine's.
If `data_paths` is provided, it is a list of directories or files to
combine. Directories are searched for files that start with
`self.filename` plus dot as a prefix, and those files are combined.
If `data_paths` is not provided, then the directory portion of
`self.filename` is used as the directory to search for data files.
Every data file found and combined is then deleted from disk. If a file
cannot be read, a warning will be issued, and the file will not be
deleted.
z.*z,Couldn't combine from non-existent path '%s'Nrf )r1 r2 rz r* �isfile�appendry �isdirr{ re r| r r
rI rx �strrU r )
r rA rf Z
data_pathsr~ r r� Zfiles_to_combine�pr� r/ Znew_datarH r r r �combine_parallel_data� s(
!
&z'CoverageDataFiles.combine_parallel_data) r rr rs rt r rc rM rE r� r r r r rw ] s rw c C s~ x: t | j d i � � D] \ } } t | � | d | <q Wx: t | j d i � � D] \ } } t | � | d | <qV Wd S)z1Canonicalize our JSON data so it can be compared.r r N)r r$ rp )rA r; r r r r r �canonicalize_json_data� s %%r� c C sI t j | d d d d �} t j d d | � } t j d d | � } | S) zLFormat data as JSON, but as nicely as possible.
Returns a string.
�indent� � sort_keysTz\[\s+(-?\d+),\s+(-?\d+)\s+]z[\1, \2]z(?m)\s+$r+ )rO �dumps�re�sub)rA �outr r r � pretty_data� s r� c C s� t j � } | j d d d d d d �| j | � \ } } x\ | pL d g D]K } t d j | � � t j | � } | j r� t | � t t
| � � qM Wd S)
zeDump the raw data from data files.
Run this as::
$ python -m coverage.data [FILE]
z-cz --canonical�action�
store_true�helpz Sort data into a canonical orderz .coveragez&--- {0} ------------------------------N) �optparse� OptionParser�
add_option�
parse_args�printr r
rQ � canonicalr� r� )�args�parser�optionsr* rA r r r �
debug_main� s
r� �__main__� ) rt r| r% rO r� r1 �os.pathr� r� r� �coverager Zcoverage.backwardr r Zcoverage.debugr Zcoverage.filesr Z
coverage.miscr r r �objectr
rw r� r� r� r �sys�argvr r r r �<module> s2 � � Fs