File: //home/arjun/projects/env/lib/python3.10/site-packages/coverage/__pycache__/sqldata.cpython-310.pyc
o
!weE� � @ s� d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlmZmZmZmZmZmZmZmZmZmZmZm Z m Z ddl m Z m Z ddl!m"Z"m#Z# ddl$m%Z% ddl&m'Z'm(Z( dd l)m*Z*m+Z+m,Z, dd
l-m.Z. dd l/m0Z0m1Z1m2Z2m3Z3m4Z4 dd l5m6Z6 e(e�Zd
Z7dZ8e dedef d�Z9d dd�Z:G dd� d�Z;d dd �Z<dS ) zSQLite coverage data.� )� annotationsN)
�cast�Any�Callable�
Collection�Dict�List�Mapping�Optional�Sequence�Set�Tuple�TypeVar�Union)� NoDebugging� auto_repr)�CoverageException� DataError)� PathAliases)� file_be_gone�isolate_module)�numbits_to_nums�
numbits_union�nums_to_numbits)�SqliteDb)�FilePath�TArc� TDebugCtl�TLineNo�TWarnFn)� __version__� a� CREATE TABLE coverage_schema (
-- One row, to record the version of the schema in this db.
version integer
);
CREATE TABLE meta (
-- Key-value pairs, to record metadata about the data
key text,
value text,
unique (key)
-- Possible keys:
-- 'has_arcs' boolean -- Is this data recording branches?
-- 'sys_argv' text -- The coverage command line that recorded the data.
-- 'version' text -- The version of coverage.py that made the file.
-- 'when' text -- Datetime when the file was created.
);
CREATE TABLE file (
-- A row per file measured.
id integer primary key,
path text,
unique (path)
);
CREATE TABLE context (
-- A row per context measured.
id integer primary key,
context text,
unique (context)
);
CREATE TABLE line_bits (
-- If recording lines, a row per context per file executed.
-- All of the line numbers for that file/context are in one numbits.
file_id integer, -- foreign key to `file`.
context_id integer, -- foreign key to `context`.
numbits blob, -- see the numbits functions in coverage.numbits
foreign key (file_id) references file (id),
foreign key (context_id) references context (id),
unique (file_id, context_id)
);
CREATE TABLE arc (
-- If recording branches, a row per context per from/to line transition executed.
file_id integer, -- foreign key to `file`.
context_id integer, -- foreign key to `context`.
fromno integer, -- line number jumped from.
tono integer, -- line number jumped to.
foreign key (file_id) references file (id),
foreign key (context_id) references context (id),
unique (file_id, context_id, fromno, tono)
);
CREATE TABLE tracer (
-- A row per file indicating the tracer used for that file.
file_id integer primary key,
tracer text,
foreign key (file_id) references file (id)
);
�TMethod.)�bound�method�returnc s t �� �d
� fdd� �}|S ) z4A decorator for methods that should hold self._lock.�self� CoverageData�argsr �kwargsr% c s� | j �d�r| j �d| j�d� j� �� | j�' | j �d�r,| j �d| j�d� j� �� � | g|�R i |��W d � S 1 sAw Y d S )N�lockzLocking z for zLocked )�_debug�should�write�_lock�__name__)r& r( r) �r$ � �I/home/arjun/projects/env/lib/python3.10/site-packages/coverage/sqldata.py�_wrappedv s $�z_locked.<locals>._wrappedN)r& r' r( r r) r r% r )� functools�wraps)r$ r3 r1 r0 r2 �_lockedt s r6 c @ s� e Zd ZdZ d}d~dd�ZeZddd�Zddd�Zddd�Z ddd�Z
d�d d �Z d�d d �Z d�d d!�Z
d�d#d$�Zd�d&d'�Zd�d�d,d-�Zd�d/d0�Zed�d2d3��Zdd4d5�Zd�d6d7�Zd�d8d9�Zed�d<d=��Zed�d@dA��Zd�d�dDdE�Zed�dHdI��Zd�d�dLdM�Zd�d�dPdQ�Z d�dRdS�Z d�d�dWdX�Z d�d�dZd[�Z dd\d]�Z dd^d_�Z!dd`da�Z"d�dbdc�Z#d�dedf�Z$d�dgdh�Z%d�didj�Z&d�dkdl�Z'd�dodp�Z(d�drds�Z)d�dudv�Z*d�dxdy�Z+e,d�d{d|��Z-dS )�r' a} Manages collected coverage data, including file storage.
This class is the public supported API to the data that 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 data file is currently a SQLite database file, with a
:ref:`documented schema <dbschema>`. The schema is subject to change
though, so be careful about querying it directly. Use this API if you
can to isolate yourself from changes.
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.
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.
A data file either stores lines, or arcs, but not both.
A data file is associated with the data when the :class:`CoverageData`
is created, using the parameters `basename`, `suffix`, and `no_disk`. The
base name can be queried with :meth:`base_filename`, and the actual file
name being used is available from :meth:`data_filename`.
To read an existing coverage.py data file, use :meth:`read`. You can then
access the line, arc, or file tracer data with :meth:`lines`, :meth:`arcs`,
or :meth:`file_tracer`.
The :meth:`has_arcs` method indicates whether arc data is available. You
can get a set of the files in the data with :meth:`measured_files`. As
with most Python containers, you can determine if there is any data at all
by using this object as a boolean value.
The contexts for each line in a file can be read with
:meth:`contexts_by_lineno`.
To limit querying to certain contexts, use :meth:`set_query_context` or
:meth:`set_query_contexts`. These will narrow the focus of subsequent
:meth:`lines`, :meth:`arcs`, and :meth:`contexts_by_lineno` calls. The set
of all measured context names can be retrieved with
:meth:`measured_contexts`.
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.
To record data for contexts, use :meth:`set_context` to set a context to
be used for subsequent :meth:`add_lines` and :meth:`add_arcs` calls.
To add a source file without any measured data, use :meth:`touch_file`,
or :meth:`touch_files` for a list of such files.
Write the data to its file with :meth:`write`.
You can clear the data in memory with :meth:`erase`. Data for specific
files can be removed from the database with :meth:`purge_files`.
Two data collections can be combined by using :meth:`update` on one
:class:`CoverageData`, passing it the other.
Data in a :class:`CoverageData` can be serialized and deserialized with
:meth:`dumps` and :meth:`loads`.
The methods used during the coverage.py collection phase
(:meth:`add_lines`, :meth:`add_arcs`, :meth:`set_context`, and
:meth:`add_file_tracers`) are thread-safe. Other methods may not be.
NF�basename�Optional[FilePath]�suffix�Optional[Union[str, bool]]�no_disk�bool�warn�Optional[TWarnFn]�debug�Optional[TDebugCtl]r% �Nonec C s� || _ tj�|p d�| _|| _|| _|pt� | _| � � i | _
i | _ t� � | _
t�� | _d| _d| _d| _d| _d| _d| _dS )a� Create a :class:`CoverageData` object to hold coverage-measured data.
Arguments:
basename (str): the base name of the data file, defaulting to
".coverage". This can be a path to a file in another directory.
suffix (str or bool): has the same meaning as the `data_suffix`
argument to :class:`coverage.Coverage`.
no_disk (bool): if True, keep all data in memory, and don't
write any disk file.
warn: a warning callback function, accepting a warning message
argument.
debug: a `DebugControl` object (optional)
z .coverageFN)�_no_disk�os�path�abspath� _basename�_suffix�_warnr r+ �_choose_filename� _file_map�_dbs�getpid�_pid� threading�RLockr. �
_have_used�
_has_lines� _has_arcs�_current_context�_current_context_id�_query_context_ids)r& r7 r9 r; r= r? r1 r1 r2 �__init__� s
zCoverageData.__init__c C s@ | j rd| _dS | j| _t| j�}|r | jd| 7 _dS dS )z.Set self._filename based on inited attributes.�:memory:�.N)rB � _filenamerF �filename_suffixrG )r& r9 r1 r1 r2 rI s
�z CoverageData._choose_filenamec C s: | j s| j�� D ]}|�� qi | _i | _d| _d| _dS )zReset our attributes.FN)rB rK �values�closerJ rP rT )r& �dbr1 r1 r2 �_reset s
zCoverageData._resetc C sD | j �d�r| j �d| j��� t| j| j �| jt�� < | �� dS )z0Open an existing db file, and read its metadata.�dataiozOpening data file N) r+ r, r- rY r rK rN � get_ident�_read_db�r& r1 r1 r2 �_open_db s zCoverageData._open_dbc C sD | j t�� ��}z
|�d�}|dusJ �W n( ty= } z dt|�v r)| �|� n
td�| j |��|�W Y d}~nd}~ww |d }|t
krPtd�| j |t
���|�d�}|durgt t |d ��| _
| j
| _|�d��}|D ] \}}|| j|< qoW d � n1 s�w Y W d � dS W d � dS 1 s�w Y dS ) zARead the metadata from a database so that we are ready to use it.z#select version from coverage_schemaNz no such table: coverage_schemaz:Data file {!r} doesn't seem to be a coverage data file: {}r z;Couldn't use data file {!r}: wrong schema: {} instead of {}z-select value from meta where key = 'has_arcs'�select id, path from file)rK rN r` � execute_one� Exception�str�_init_dbr �formatrY �SCHEMA_VERSIONr< �intrR rQ �executerJ )r& r] �row�exc�schema_version�cur�file_idrD r1 r1 r2 ra " sH
��� ���
��
� ��"�zCoverageData._read_dbr] r c C s� | j �d�r| j �d| j��� |�t� |�dtf� dtfg}| j �d�r>|� dt
t t dd��fd t
j
�� �d
�fg� |�d |� dS ) z+Write the initial contents of the database.r_ zIniting data file z0insert into coverage_schema (version) values (?)�version�process�sys_argv�argvN�whenz%Y-%m-%d %H:%M:%S�5insert or ignore into meta (key, value) values (?, ?))r+ r, r- rY �
executescript�SCHEMA� execute_voidrj r �extendrg �getattr�sys�datetime�now�strftime�executemany_void)r& r] � meta_datar1 r1 r2 rh C s
� �zCoverageData._init_dbc C s$ t �� | jvr | �� | jt �� S )z Get the SqliteDb object to use.)rN r` rK rc rb r1 r1 r2 �_connectV s zCoverageData._connectc C s� t �� | jvrtj�| j�sdS z<| �� �-}|�d��}t t
|��W d � W d � W S 1 s4w Y W d � W d S 1 sEw Y W d S t yV Y dS w )NFzselect * from file limit 1) rN r` rK rC rD �existsrY r� rl r< �listr )r& �conrp r1 r1 r2 �__bool__\ s
��&� �zCoverageData.__bool__�bytesc C sh | j �d�r| j �d| j��� | �� �}|�� }dt�|�d�� W d � S 1 s-w Y dS )a Serialize the current data to a byte string.
The format of the serialized data is not documented. It is only
suitable for use with :meth:`loads` in the same version of
coverage.py.
Note that this serialization is not what gets stored in coverage data
files. This method is meant to produce bytes that can be transmitted
elsewhere and then deserialized with :meth:`loads`.
Returns:
A byte string of serialized data.
.. versionadded:: 5.0
r_ z Dumping data from data file � z�utf-8N) r+ r, r- rY r� �dump�zlib�compress�encode)r& r� �scriptr1 r1 r2 �dumpsf s
$�zCoverageData.dumps�datac C s� | j �d�r| j �d| j��� |dd� dkr)td|dd� �dt|�� d ���t�|dd� ��d
�}t | j| j � | j
t � � < }|�
|�
|� W d � n1 sUw Y | �� d | _dS ) a� Deserialize data from :meth:`dumps`.
Use with a newly-created empty :class:`CoverageData` object. It's
undefined what happens if the object already has data in it.
Note that this is not for reading data from a coverage data file. It
is only for use on data you produced with :meth:`dumps`.
Arguments:
data: A byte string of serialized data produced by :meth:`dumps`.
.. versionadded:: 5.0
r_ z Loading data into data file N� r� z Unrecognized serialization: �( z
(head of z bytes)r� T)r+ r, r- rY r �lenr� �
decompress�decoder rK rN r` rx ra rP )r& r� r� r] r1 r1 r2 �loads} s � �
zCoverageData.loads�filenamerg �add�
Optional[int]c C sV || j vr%|r%| �� �}|�d|f�| j |< W d � n1 s w Y | j �|�S )z�Get the file id for `filename`.
If filename is not in the database yet, add it if `add` is True.
If `add` is not True, return None.
z-insert or replace into file (path) values (?)N)rJ r� �execute_for_rowid�get)r& r� r� r� r1 r1 r2 �_file_id� s
� � zCoverageData._file_id�contextc C sv |dusJ �| � � | �� �#}|�d|f�}|dur(tt|d �W d � S W d � dS 1 s4w Y dS )zGet the id for a context.N�(select id from context where context = ?r )� _start_usingr� re r rk )r& r� r� rm r1 r1 r2 � _context_id� s
�$�zCoverageData._context_id�
Optional[str]c C s. | j �d�r| j �d|��� || _d| _dS )z�Set the current context for future :meth:`add_lines` etc.
`context` is a str, the name of the context to use for the next data
additions. The context persists until the next :meth:`set_context`.
.. versionadded:: 5.0
�dataopzSetting context: N)r+ r, r- rS rT )r& r� r1 r1 r2 � set_context� s
zCoverageData.set_contextc C sd | j pd}| �|�}|dur|| _dS | �� �}|�d|f�| _W d � dS 1 s+w Y dS )z4Use the _current_context to set _current_context_id.� Nz(insert into context (context) values (?))rS r� rT r� r� )r& r� �
context_idr� r1 r1 r2 �_set_context_id� s
�"�z CoverageData._set_context_idc C � | j S )zLThe base filename for storing data.
.. versionadded:: 5.0
)rF rb r1 r1 r2 �
base_filename� � zCoverageData.base_filenamec C r� )zBWhere is the data stored?
.. versionadded:: 5.0
)rY rb r1 r1 r2 �
data_filename� r� zCoverageData.data_filename� line_data�!Mapping[str, Collection[TLineNo]]c
C s | j �d�r| j �dt|�tdd� |�� D ��f � | �� | jdd� |s)dS | �� �U}| � � |�
� D ]C\}}t |�}| j |dd�}d }|�
||| jf�� }t|�} W d � n1 s_w Y | rot|| d
d
�}|�d || j|f� q6W d � dS 1 s�w Y dS ) z�Add measured line data.
`line_data` is a dictionary mapping file names to iterables of ints::
{ filename: { line1, line2, ... }, ...}
r� z&Adding lines: %d files, %d lines totalc s s � | ] }t t|��V qd S �N)r< r� )�.0�linesr1 r1 r2 � <genexpr>� s � z)CoverageData.add_lines.<locals>.<genexpr>T�r� N�r� zBselect numbits from line_bits where file_id = ? and context_id = ?r zQinsert or replace into line_bits (file_id, context_id, numbits) values (?, ?, ?))r+ r, r- r� �sumr[ r� �_choose_lines_or_arcsr� r� �itemsr r� rl rT r� r rz )
r& r� r� r� �linenos�linemaprq �queryrp �existingr1 r1 r2 � add_lines� s2 �
�
��"�zCoverageData.add_lines�arc_data� Mapping[str, Collection[TArc]]c s� �j �d�r�j �dt|�tdd� |�� D ��f � ��� �jdd� |s)dS ��� �0}�� � |�
� D ] \}}|s=q6�j |dd�� � �fd d
�|D �}|� d |� q6W d � dS 1 s`w Y dS ) z�Add measured arc data.
`arc_data` is a dictionary mapping file names to iterables of pairs of
ints::
{ filename: { (l1,l2), (l1,l2), ... }, ...}
r� z$Adding arcs: %d files, %d arcs totalc s s � | ]}t |�V qd S r� )r� )r� �arcsr1 r1 r2 r�
s � z(CoverageData.add_arcs.<locals>.<genexpr>T�r� Nr� c s g | ] \}}� �j ||f�qS r1 )rT )r� �fromno�tono�rq r& r1 r2 �
<listcomp> s z)CoverageData.add_arcs.<locals>.<listcomp>�Qinsert or ignore into arc (file_id, context_id, fromno, tono) values (?, ?, ?, ?))
r+ r, r- r� r� r[ r� r� r� r� r� r� r� )r& r� r� r� r� r� r1 r� r2 �add_arcs s*
�
��"�zCoverageData.add_arcsr� r� c C s� |s|sJ �|r |r J �|r!| j r!| j�d�r | j�d� td��|r6| jr6| j�d�r2| j�d� td��| j se| jsg|| _|| _ | �� �}|�ddtt |��f� W d � dS 1 s^w Y dS dS dS ) z5Force the data file to choose between lines and arcs.r� z:Error: Can't add line measurements to existing branch dataz3Can't add line measurements to existing branch dataz:Error: Can't add branch measurements to existing line dataz3Can't add branch measurements to existing line datarw �has_arcsN)
rR r+ r, r- r rQ r� rz rg rk )r& r� r� r� r1 r1 r2 r� s(
�"��z"CoverageData._choose_lines_or_arcs� file_tracers�Mapping[str, str]c C s� | j �d�r| j �dt|�f � |sdS | �� | �� �8}|�� D ]*\}}| j|dd�}| �|�}|rB||krAt d�
|||���q"|rL|� d||f� q"W d � dS 1 sXw Y dS )zdAdd per-file plugin information.
`file_tracers` is { filename: plugin_name, ... }
r� z Adding file tracers: %d filesNTr� �3Conflicting file tracer name for '{}': {!r} vs {!r}z2insert into tracer (file_id, tracer) values (?, ?)) r+ r, r- r� r� r� r� r� � file_tracerr ri rz )r& r� r� r� � plugin_namerq �existing_pluginr1 r1 r2 �add_file_tracers5 s2
������"�z CoverageData.add_file_tracersr� r� c C s | � |g|� dS )z�Ensure that `filename` appears in the data, empty if needed.
`plugin_name` is the name of the plugin responsible for this file.
It is used to associate the right filereporter, etc.
N)� touch_files)r& r� r� r1 r1 r2 �
touch_fileR s zCoverageData.touch_file� filenames�Collection[str]c C s� | j �d�r| j �d|��� | �� | �� �( | js"| js"td��|D ]}| j|dd� |r6| � ||i� q$W d � dS 1 sBw Y dS )z�Ensure that `filenames` appear in the data, empty if needed.
`plugin_name` is the name of the plugin responsible for these files.
It is used to associate the right filereporter, etc.
r� z Touching z*Can't touch files in an empty CoverageDataTr� N)
r+ r, r- r� r� rR rQ r r� r� )r& r� r� r� r1 r1 r2 r� Z s
��"�zCoverageData.touch_filesc C s� | j �d�r| j �d|��� | �� | �� �1}| jr d}n
| jr$d}ntd��|D ]}| j|dd�}|du r8q*|� ||f� q*W d � dS 1 sKw Y dS ) zdPurge any existing coverage data for the given `filenames`.
.. versionadded:: 7.2
r� zPurging data for z%delete from line_bits where file_id=?z delete from arc where file_id=?z*Can't purge files in an empty CoverageDataFr� N)
r+ r, r- r� r� rQ rR r r� rz )r& r� r� �sqlr� rq r1 r1 r2 � purge_filesm s
�"�zCoverageData.purge_files�
other_data�aliases�Optional[PathAliases]c s� | j �d�r| j �d�t|dd��� | jr |jr td��| jr'|jr'td��� p+t� � | � � |�
� |� � ��}|� d��}� fdd �|D ��W d
� n1 sRw Y |� d ��}d d
� |D �}W d
� n1 snw Y |� d��}�fdd
�|D �}W d
� n1 s�w Y |� d��'}i }|D ]\}} }
�| | f} | |v r�t
|| |
�}
|
|| < q�W d
� n1 s�w Y |� d��}�fdd �|D �} W d
� n1 s�w Y W d
� n1 s�w Y | � � ��R}|jd
us�J �d|j_|� d��}dd � |D �}
W d
� n 1 �sw Y |� d��}|
�� fdd �|D �� W d
� n 1 �s=w Y |�ddd� ��� D �� |� d��}dd � |D ��W d
� n 1 �sgw Y | j��� |�dd d� |D �� |� d ��}d d � |D ��W d
� n 1 �s�w Y i }��� D ]%}|
�|�}| �|d �}|d
u�r�||k�r�td �|||���|||< �q���fd!d�|D �}|� d��(}|D ] \}} }
� �|�| f} | |v �r�t
|| |
�}
|
|| < �q�W d
� n 1 �sw Y |�r| jd"d#� |�d$|� |�r3| jd"d%� |�d&� |�d'��fd(d
�|�� D �� |�d)�fd*d�|�� D �� W d
� n 1 �sMw Y | j�s`| �� | �
� d
S d
S )+a* Update this data with data from several other :class:`CoverageData` instances.
If `aliases` is provided, it's a `PathAliases` object that is used to
re-map paths to match the local machine's. Note: `aliases` is None
only when called directly from the test suite.
r� z Updating with data from {!r}rY z???z%Can't combine arc data with line dataz%Can't combine line data with arc datazselect path from filec s i | ] \}|� � |��qS r1 ��map�r� rD �r� r1 r2 �
<dictcomp>� � z'CoverageData.update.<locals>.<dictcomp>Nzselect context from contextc S s g | ]\}|�qS r1 r1 �r� r� r1 r1 r2 r� � s z'CoverageData.update.<locals>.<listcomp>z�select file.path, context.context, arc.fromno, arc.tono from arc inner join file on file.id = arc.file_id inner join context on context.id = arc.context_idc s$ g | ]\}}}}� | |||f�qS r1 r1 )r� rD r� r� r� ��filesr1 r2 r� � s
��z�select file.path, context.context, line_bits.numbits from line_bits inner join file on file.id = line_bits.file_id inner join context on context.id = line_bits.context_idzPselect file.path, tracer from tracer inner join file on file.id = tracer.file_idc s i | ] \}}� | |�qS r1 r1 �r� rD �tracerr� r1 r2 r� � r� � IMMEDIATEc S s i | ]\}|d �qS �r� r1 r� r1 r1 r2 r� � � c s i | ]
\}}� � |�|�qS r1 r� r� r� r1 r2 r� � s
��z,insert or ignore into file (path) values (?)c s � � | ]}|fV qd S r� r1 )r� �filer1 r1 r2 r� � � � z&CoverageData.update.<locals>.<genexpr>rd c S � i | ]\}}||�qS r1 r1 )r� �idrD r1 r1 r2 r� � � z2insert or ignore into context (context) values (?)c s r� r� r1 r� r1 r1 r2 r� � r� z select id, context from contextc S r� r1 r1 )r� r� r� r1 r1 r2 r� � r� r� r� c 3 s, � | ]\}}}}�| � | ||fV qd S r� r1 )r� r� r� r� r� �� context_ids�file_idsr1 r2 r� � s
�
�
�Tr� r� r� zdelete from line_bitszEinsert into line_bits (file_id, context_id, numbits) values (?, ?, ?)c s& g | ]\\}}}�| � | |f�qS r1 r1 )r� r� r� �numbitsr� r1 r2 r� s
��z<insert or ignore into tracer (file_id, tracer) values (?, ?)c 3 s � | ] \}}� | |fV qd S r� r1 )r� r� r� )r� r1 r2 r� & s � )r+ r, r- ri r| rQ rR r r r� �readr� rl r r� �isolation_level�updater� r[ rJ r� r� r� rz r� rB r^ )r& r� r� r� rp �contextsr� r� rD r� r� �key�tracers� this_tracers�
tracer_map� this_tracer� other_tracer�arc_rowsr1 )r� r� r� r� r2 r� � s�
�
� ��
� � �
� �� �� � + ��
� �
� � � �
�� ��
� � �
��� �a �zCoverageData.update�parallelc C s� | � � | jr dS | j�d�r| j�d| j��� t| j� |rVtj� | j�\}}tj�
tj� |�|�}t �
|�d }t � |�D ]}| j�d�rQ| j�d|��� t|� q@dS dS )z�Erase the data in this object.
If `parallel` is true, then also deletes data files created from the
basename by parallel-mode.
Nr_ zErasing data file z.*zErasing parallel data file )r^ rB r+ r, r- rY r rC rD �split�joinrE �glob�escape)r& r� �data_dir�local�local_abs_path�patternr� r1 r1 r2 �erase. s
�zCoverageData.erasec C sF t j�| j�r!| �� � d| _W d � dS 1 sw Y dS dS )z"Start using an existing data file.TN)rC rD r� rY r� rP rb r1 r1 r2 r� D s
"��zCoverageData.readc C s dS )z,Ensure the data is written to the data file.Nr1 rb r1 r1 r2 r- J s zCoverageData.writec C s@ | j t�� kr| �� | �� t�� | _ | js| �� d| _dS )z+Call this before using the database at all.TN)rM rC rL r^ rI rP r rb r1 r1 r2 r� N s
zCoverageData._start_usingc C �
t | j�S )z4Does the database have arcs (True) or lines (False).)r< rR rb r1 r1 r2 r� Y s
zCoverageData.has_arcs�Set[str]c C r )z�A set of all files that have been measured.
Note that a file may be mentioned as measured even though no lines or
arcs for that file are present in the data.
)�setrJ rb r1 r1 r2 �measured_files] s
zCoverageData.measured_filesc C s~ | � � | �� �-}|�d��}dd� |D �}W d � n1 s w Y W d � |S W d � |S 1 s8w Y |S )zWA set of all contexts that have been measured.
.. versionadded:: 5.0
z%select distinct(context) from contextc S s h | ]}|d �qS �r r1 �r� rm r1 r1 r2 � <setcomp>o r� z1CoverageData.measured_contexts.<locals>.<setcomp>N)r� r� rl )r& r� rp r� r1 r1 r2 �measured_contextsf s
�
��
��z CoverageData.measured_contextsc C s� | � � | �� �4}| �|�}|du r W d � dS |�d|f�}|dur3|d p+dW d � S W d � dS 1 s?w Y dS )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.
Nz+select tracer from tracer where file_id = ?r r� )r� r� r� re )r& r� r� rq rm r1 r1 r2 r� r s
�
�$�zCoverageData.file_tracerc C s� | � � | �� �2}|�d|f��}dd� |�� D �| _W d � n1 s%w Y W d � dS W d � dS 1 s=w Y dS )ad Set a context for subsequent querying.
The next :meth:`lines`, :meth:`arcs`, or :meth:`contexts_by_lineno`
calls will be limited to only one context. `context` is a string which
must match a context exactly. If it does not, no exception is raised,
but queries will return no data.
.. versionadded:: 5.0
r� c S � g | ]}|d �qS r r1 r r1 r1 r2 r� � r� z2CoverageData.set_query_context.<locals>.<listcomp>N)r� r� rl �fetchallrU )r& r� r� rp r1 r1 r2 �set_query_context� s
��"�z CoverageData.set_query_contextr� �Optional[Sequence[str]]c C s� | � � |rQ| �� �=}d�dgt|� �}|�d| |��}dd� |�� D �| _W d � n1 s2w Y W d � dS W d � dS 1 sJw Y dS d| _dS )a� Set a number of contexts for subsequent querying.
The next :meth:`lines`, :meth:`arcs`, or :meth:`contexts_by_lineno`
calls will be limited to the specified contexts. `contexts` is a list
of Python regular expressions. Contexts will be matched using
:func:`re.search <python:re.search>`. Data will be included in query
results if they are part of any of the contexts matched.
.. versionadded:: 5.0
z or zcontext regexp ?z select id from context where c S r r r1 r r1 r1 r2 r� � r� z3CoverageData.set_query_contexts.<locals>.<listcomp>N)r� r� r� r� rl r
rU )r& r� r� �context_clauserp r1 r1 r2 �set_query_contexts� s
��"�
z CoverageData.set_query_contexts�Optional[List[TLineNo]]c
C s0 | � � | �� r | �|�}|dur tj�|�}tdd� |D ��S | �� �j}| �|�}|du r7 W d � dS d}|g}| j durXd�
dt | j � �}|d| d 7 }|| j 7 }|� ||�� } t| �}
W d � n1 smw Y t
� } |
D ] } | �t| d �� qwt| �W d � S 1 s�w Y dS )
aj Get the list of lines executed for a source 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 h | ]}|d kr|�qS r r1 )r� �lr1 r1 r2 r
� s z%CoverageData.lines.<locals>.<setcomp>z/select numbits from line_bits where file_id = ?�, �?� and context_id in (�)r )r� r� r� � itertools�chain�
from_iterabler� r� r� rU r� r� rl r r� r )
r& r� r� � all_linesr� rq r� r� � ids_arrayrp �bitmaps�numsrm r1 r1 r2 r� � s2
�
�$�zCoverageData.lines�Optional[List[TArc]]c C s� | � � | �� �]}| �|�}|du r W d � dS d}|g}| jdur<d�dt| j� �}|d| d 7 }|| j7 }|�||��}t|�W d � W d � S 1 sXw Y W d � dS 1 shw Y dS )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.
Nz7select distinct fromno, tono from arc where file_id = ?r r r r )r� r� r� rU r� r� rl r� )r& r� r� rq r� r� r rp r1 r1 r2 r� � s$
�
�� "�zCoverageData.arcs�Dict[TLineNo, List[str]]c C s� | � � | �� ��}| �|�}|du ri W d � S t�t�}| �� rzd}|g}| jdurEd�dt | j� �}|d| d 7 }|| j7 }|�
||��&}|D ]\} }
} | dkr^|| � | � |
dkri||
� | � qNW d � n1 stw Y nLd}|g}| jdur�d�dt | j� �}|d | d 7 }|| j7 }|�
||�� }|D ]\} } t | �D ] }
||
� | � q�q�W d � n1 s�w Y W d � n1 s�w Y d
d � |�
� D �S ) z�Get the contexts for each line in a file.
Returns:
A dict mapping line numbers to a list of context names.
.. versionadded:: 5.0
Nztselect arc.fromno, arc.tono, context.context from arc, context where arc.file_id = ? and arc.context_id = context.idr r z and arc.context_id in (r r zaselect l.numbits, c.context from line_bits l, context c where l.context_id = c.id and file_id = ?z and l.context_id in (c S s i | ] \}}|t |��qS r1 )r� )r� �linenor� r1 r1 r2 r� r� z3CoverageData.contexts_by_lineno.<locals>.<dictcomp>)r� r� r� � collections� defaultdictr r� rU r� r� rl r� r r� )r& r� r� rq �lineno_contexts_mapr� r� r rp r� r� r� r� r! r1 r1 r2 �contexts_by_lineno� sT
�
�
�� ���
�� �� �'z CoverageData.contexts_by_lineno�List[Tuple[str, Any]]c C s� t dt� d��J}|�d��}dd� |D �}W d � n1 s w Y |�d��}dd� |D �}W d � n1 s;w Y tjd �|�d
d �}W d � n1 sTw Y d tjfd
|fd|fgS )zaOur information for `Coverage.sys_info`.
Returns a list of (key, value) pairs.
rW )r? zpragma temp_storec S r r r1 r r1 r1 r2 r� ( r� z)CoverageData.sys_info.<locals>.<listcomp>Nzpragma compile_optionsc S r r r1 r r1 r1 r2 r� * r� r �K )�width�sqlite3_sqlite_version�sqlite3_temp_store�sqlite3_compile_options)r r rl �textwrap�wrapr� �sqlite3�sqlite_version)�clsr] rp �
temp_store�coptsr1 r1 r2 �sys_info s � � ��zCoverageData.sys_info)NNFNN) r7 r8 r9 r: r; r< r= r> r? r@ r% rA )r% rA )r] r r% rA )r% r )r% r< )r% r� )r� r� r% rA )F)r� rg r� r< r% r� )r� rg r% r� )r� r� r% rA )r% rg )r� r� r% rA )r� r� r% rA )FF)r� r< r� r< r% rA )r� r� r% rA r� )r� rg r� rg r% rA r� )r� r� r� r� r% rA )r� r� r% rA )r� r' r� r� r% rA )r� r< r% rA )r% r )r� rg r% r� )r� rg r% rA )r� r r% rA )r� rg r% r )r� rg r% r )r� rg r% r )r% r& ).r/ �
__module__� __qualname__�__doc__rV r �__repr__rI r^ rc ra rh r� r� r� r� r� r� r6 r� r� r� r� r� r� r� r� r� r� r� r� r r� r- r� r� r r r� r r r� r� r% � classmethodr3 r1 r1 r1 r2 r' � sh V �/
!
!
*
#
3r' r9 �Union[str, bool, None]�Union[str, None]c C sJ | du r t �t�d���dd�}dt�� t�� |f } | S | du r#d} | S )z�Compute a filename suffix for a data file.
If `suffix` is a string or None, simply return it. If `suffix` is True,
then build a suffix incorporating the hostname, process id, and a random
number.
Returns a string or None.
T� r i?B z
%s.%s.%06dFN)�random�RandomrC �urandom�randint�socket� gethostnamerL )r9 �dicer1 r1 r2 rZ 4 s
�rZ )r$ r" r% r" )r9 r9 r% r: )=r6 �
__future__r r" r~ r4 r� r rC r< r@ r. r} r, rN r� �typingr r r r r r r r
r r r
r r �coverage.debugr r �coverage.exceptionsr r �coverage.filesr �
coverage.miscr r �coverage.numbitsr r r �coverage.sqlitedbr �coverage.typesr r r r r �coverage.versionr rj ry r" r6 r' rZ r1 r1 r1 r2 �<module> sL < >
: