B

ºsL¡1{!ã@s®
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	m
Z

d
dlmZ
d
dl
mZmZmZmZ
eeƒ
Zdd„Zdd	„Zed
d
dd
„ƒ
Zed
d
dd„ƒ
ZdZed
d
ddd„ƒ
Ze
jràiZiZdd„Zndd„Ze
j
red
d
dd„ƒ
Zned
d
ddd„ƒ
Zed
d
dd„ƒ
Zdd„Zda da!eƒ
dd„Z"d d!„Z#Gd"d#„d#e$ƒZ%Gd$d%„d%e$ƒZ&Gd&d'„d'e$ƒZ'd(d)„Z(d1d+d,„
Z)Gd-d.„d.e$ƒZ*d/d0„Z+dS)2zFile wrangling.éN)
Úenv)
Ú
unicode_class)ÚcontractÚCoverageExceptionÚ
join_regexÚisolate_modulecCs tj
 ttjƒ
tj¡
aiad
S)z?Set the directory that `relative_filename` will be relative to.N)ÚosÚpathÚnormcaseÚabs_fileÚcurdirÚsepÚRELATIVE_DIRÚCANONICAL_FILENAME_CACHE©rrúŒ/build/wlanpi-profiler-MIf3Xw/wlanpi-profiler-1.0.8/debian/wlanpi-profiler/opt/wlanpi-profiler/lib/python3.7/site-packages/coverage/files.pyÚset_relative_directorysrc
CstS)
z=Return the directory that `relative_filename` is relative to.)
rrrrrÚrelative_directory#srÚunicode)
Úreturnsc
Cs.tj
 |¡
}
|
 t¡
r&|ttƒ
d
…}t|ƒ
S)zœReturn the relative form of `filename`.

    The file name will be relative to the current directory when the
    `set_relative_directory` was called.

    N)rr	r
Ú
startswithrÚlenÚunicode_filename)ÚfilenameZfnormrrrÚrelative_filename(s



rc
	Cs”|tkrŒ|}
t
j |¡
s|xbt
jg
tjD]P}|d
kr6q(t
j ||¡}yt
j |¡
}Wntk
rl


d}YnX|r(|}
Pq(Wt	|
ƒ
}
|
t|<t|S)zzReturn a canonical file name for `filename`.

    An absolute path with no redundant components and normalized case.

    NF)
rrr	ÚisabsrÚsysÚjoinÚexistsÚUnicodeErrorr)rÚcfr	Ú
frrrrÚcanonical_filename6s"
















r"éÈ)rrc
Csbt 
|¡
d
}
t dd|
¡}
t|
ƒ
tkr^t |
 d¡
¡
 	¡}|
tt|ƒ
d
d…d|}
|
S)a(
A base for a flat file name to correspond to this file.

    Useful for writing files about the code where you want all the files in
    the same directory, but need to differentiate same-named files from
    different directories.

    For example, the file a/b/c.py will return 'a_b_c_py'

    é
z[\\/.:]Ú
_zUTF-8N)
ÚntpathÚ
splitdriveÚreÚsubrÚMAX_FLATÚhashlibÚsha1ÚencodeÚ	hexdigest)rÚnameÚ
hrrrÚ
flat_rootnameRs



"
r1c
Csêtj
rt|tƒr| t ¡¡
}|tkr.t|Stj	 
|¡
\}
}|sL|
 ¡}n’|
sV|}nˆt|
ƒ
}
|
t
krpt
|
}n0yt |
¡
}Wntk
r–


g}YnX|t
|
<tj	 |¡
}x"|D]}tj	 |¡
|kr²|}Pq²Wtj	 |
|¡}|t|<|S)
z:Get the actual path of `path`, including the correct case.)rÚPY2Ú
isinstancerr-rÚgetfilesystemencodingÚ_ACTUAL_PATH_CACHErr	ÚsplitÚupperÚactual_pathÚ_ACTUAL_PATH_LIST_CACHEÚlistdirÚ	Exceptionr
r)r	ÚheadÚtailZactpathÚfilesZnormtailr!rrrr8js2






















r8c


Cs|S)
z*The actual path for non-Windows platforms.r)
rrrrr8sc
Cs*t|t
ƒr&t ¡pt ¡}
| |
d
¡}|S)z'Return a Unicode version of `filename`.Úreplace)r3Ústrrr4ÚgetdefaultencodingÚdecode)rÚencodingrrrr“s



rc


Cs|S)
z'Return a Unicode version of `filename`.r)
rrrrr›sc

CsFytj
 |¡
}Wntk
r$


YnXtj
 |¡
}t|ƒ
}t|ƒ
}|S)
z.Return the absolute normalized form of `path`.)rr	ÚrealpathrÚabspathr8r)
r	rrrr¡s






rc

Cstj
jrtj |¡
}|S)
z:Return the string as Python would describe this file name.)rZ
PYBEHAVIORZreport_absolute_filesrr	rE)
rrrrÚpython_reported_file®s

rFc

Cst 
|¡
pt 
|¡
S)
z)Is `filename` an absolute path on any OS?)r&rÚ	posixpath)
rrrrÚisabs_anywhereºsrHc
Cs>g}
x4|pgD](}| d
¡
r(|
 
|¡

q|
 
t|ƒ
¡

qW|
S)a"
Prepare the file patterns for use in a `FnmatchMatcher`.

    If a pattern starts with a wildcard, it is used as a pattern
    as-is.  If it does not start with a wildcard, then it is made
    absolute with the current directory.

    If `patterns` is None, an empty list is returned.

    )Ú
*ú
?)rÚappendr)ÚpatternsZpreppedÚ
prrrÚ
prep_patterns¿s





rNc@s0eZ
dZd
Zdd„Zdd„Zdd„Zdd	„Zd
S)ÚTreeMatcherzøA matcher for files in a tree.

    Construct with a list of paths, either files or directories. Paths match
    with the `match` method if they are one of the files, or if they are
    somewhere in a subtree rooted at one of the directories.

    cCst|
ƒ
|_
dS)
N)ÚlistÚpaths)ÚselfrQrrrÚ__init__Ús
zTreeMatcher.__init__c

Cs
d
|jS)Nz<TreeMatcher %r>)
rQ)
rRrrrÚ__repr__Ýs
zTreeMatcher.__repr__c


Cs|jS)
z4A list of strings for displaying when dumping state.)
rQ)
rRrrrÚinfoàszTreeMatcher.infocCs@x:|jD]0}|
 
|¡
r|
|kr"d
S|
t|ƒ
tjkrd
SqWdS)z1Does `fpath` indicate a file in one of our trees?TF)rQrrrr
)rRÚfpathrMrrrÚmatchäs




zTreeMatcher.matchN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rSrTrUrWrrrrrOÒs

rOc@s0eZ
dZd
Zdd„Zdd„Zdd„Zdd	„Zd
S)Ú
ModuleMatcherz A matcher for modules in a tree.cCst|
ƒ
|_
dS)
N)rPÚmodules)rRZmodule_namesrrrrSós
zModuleMatcher.__init__c

Cs
d
|jS)Nz<ModuleMatcher %r>)
r])
rRrrrrTös
zModuleMatcher.__repr__c


Cs|jS)
z4A list of strings for displaying when dumping state.)
r])
rRrrrrUùszModuleMatcher.infocCsF|
sd
Sx8|jD].}|
 
|¡
r|
|kr*dS|
t|ƒ
dkrdSqWd
S)z<Does `module_name` indicate a module in one of our packages?FTÚ
.)r]rr)rRÚmodule_nameÚ
mrrrrWýs





zModuleMatcher.matchN)rXrYrZr[rSrTrUrWrrrrr\ñs


r\c@s0eZ
dZd
Zdd„Zdd„Zdd„Zdd	„Zd
S)ÚFnmatchMatcherz)A matcher for files by file name pattern.cCs t|
ƒ
|_
t|j
tjd
|_dS)N)
Úcase_insensitive)rPÚpatsÚfnmatches_to_regexrÚWINDOWSr()rRrcrrrrS
s


zFnmatchMatcher.__init__c

Cs
d
|jS)Nz<FnmatchMatcher %r>)
rc)
rRrrrrT
s
zFnmatchMatcher.__repr__c


Cs|jS)
z4A list of strings for displaying when dumping state.)
rc)
rRrrrrU
szFnmatchMatcher.infocCs|j 
|
¡
d
k	S)z1Does `fpath` match one of our file name patterns?N)r(rW)rRrVrrrrW
szFnmatchMatcher.matchN)rXrYrZr[rSrTrUrWrrrrra

s


rac
Cs&t 
d
|¡}
|
r|
 d¡
}ntj}|S)z?Find the path separator used in this string, or os.sep if none.z[\\/]r
)r(ÚsearchÚgrouprr
)Ú
sZ	sep_matchZthe_seprrrr

s



r
FcCsVd
d„|Dƒ
}dd„|Dƒ
}|r.dd„|Dƒ
}d}|
r@|tj
O}tjt|ƒ
|d}|S)aº
Convert fnmatch patterns to a compiled regex that matches any of them.

    Slashes are always converted to match either slash or backslash, for
    Windows support, even when running elsewhere.

    If `partial` is true, then the pattern will match if the target string
    starts with the pattern. Otherwise, it must match the entire string.

    Returns: a compiled regex object.  Use the .match method to compare target
    strings.

    c
ss|]}
t 
|
¡
V
qdS)
N)ÚfnmatchÚ	translate)Ú.0Úpatternrrrú	<genexpr>6
sz%fnmatches_to_regex.<locals>.<genexpr>c
ss|]}
t 
dd
|
¡V
qdS)z\\?/z[\\\\/]N)r(r))rkÚregexrrrrm9
sc
ss|]}
t 
dd
|
¡V
qdS)z\\Z(\(\?|$)z\1N)r(r))rkrnrrrrm@
sr
)
Úflags)r(Ú
IGNORECASEÚcompiler)rLrbÚpartialZregexesroZcompiledrrrrd)
s




rdc@s0eZ
dZd
Zdd„Zdd„Zdd„Zdd	„Zd
S)ÚPathAliasesa‰
A collection of aliases for paths.

    When combining data files from remote machines, often the paths to source
    code are different, for example, due to OS differences, or because of
    serialized checkouts on continuous integration machines.

    A `PathAliases` object tracks a list of pattern/result pairs, and can
    map a path through those aliases to produce a unified path.

    c

Cs
g|_dS)
N)
Úaliases)
rRrrrrSU
s
zPathAliases.__init__c
Cs*x$|jD]\}
}t
d
 |
j|¡ƒ

qWdS)z;Dump the important parts of the PathAliases, for debugging.z
{!r} --> {!r}N)rtÚprintÚformatrl)rRrnÚresultrrrÚpprintX
s
zPathAliases.pprintcCsšt|
ƒ
}t
|
ƒ
d
kr|
 d¡
}
|
 d¡
r0tdƒ
‚
|
 d¡
sNt|
|ƒ
sNt|
ƒ
}
|
 |¡
s`|
|7}
t|
g
ddd}t|ƒ
}| d¡
|}|j	 
||f¡

dS)a
Add the `pattern`/`result` pair to the list of aliases.

        `pattern` is an `fnmatch`-style pattern.  `result` is a simple
        string.  When mapping paths, if a path starts with a match against
        `pattern`, then that match is replaced with `result`.  This models
        isomorphic source trees being rooted at different places on two
        different machines.

        `pattern` can't end with a wildcard component, since that would
        match an entire tree, and not just its root.

        r$z\/rIz$Pattern must not end with wildcards.T)rbrrN)r
rÚrstripÚendswithrrrHrrdrtrK)rRrlrwZpattern_seprnZ
result_seprrrÚadd]
s











zPathAliases.addcCsXxR|jD]H\}}| 
|
¡
}|r|
 | d
¡
|¡}| t|
ƒ
t|ƒ
¡}t|ƒ
}|SqW|
S)a?Map `path` through the aliases.

        `path` is checked against all of the patterns.  The first pattern to
        match is used to replace the root of the path with the result root.
        Only one pattern is ever used.  If no patterns match, `path` is
        returned unchanged.

        The separator style in the result is made to match that of the result
        in the alias.

        Returns the mapped path.  If a mapping has happened, this is a
        canonical path.  If no mapping has happened, it is the original value
        of `path` unchanged.

        r
)rtrWr?rgr
r")rRr	rnrwr`ÚnewrrrÚmapƒ
s







zPathAliases.mapN)rXrYrZr[rSrxr{r}rrrrrsJ
s


&rsc
cslxftt
 |¡
ƒ
D]T\}
\}}}|
d
kr:d|kr:|dd…=qx(|D] }t d|¡r@t
j ||¡V
q@WqWdS)a™
Yield all of the importable Python files in `dirname`, recursively.

    To be importable, the files have to be in a directory with a __init__.py,
    except for `dirname` itself, which isn't required to have one.  The
    assumption is that `dirname` was specified directly, so the user knows
    best, but sub-directories are checked for a __init__.py to be sure we only
    find the importable files.

    r
z__init__.pyNz^[^.#~!$@%^&*()+=,]+\.pyw?$)Ú	enumeraterÚwalkr(rWr	r)ÚdirnameÚ
iÚdirpathÚdirnamesÚ	filenamesrrrrÚfind_python_files
s






r…)FF),r[r+rir&rÚos.pathrGr(rZcoveragerZcoverage.backwardrZ
coverage.miscrrrrrrrr"r*r1rer5r9r8r2rrrFrrrHrNÚobjectrOr\rar
rdrsr…rrrrÚ<module>sP










#





!S