B

kŽÏë%
Ðã@s¤dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZddlmZ
ddlm	Z	
ddl
mZ
dg
Ze 
e¡
Ze dej¡Ze d	ejejB¡Zejdd
…ZGdd„deƒZdS)zu
Class representing the list of files in a distribution.

Equivalent to distutils.filelist, but fixes some problems.
éNé
)
ÚDistlibException)
Úfsdecode)
Úconvert_pathÚManifestz\\w*
z#.*?(?=
)|
(?=$)éc@szeZ
dZd
Zddd„
Zdd„Zdd„Zd	d
„Zddd
„
Zdd„Z	dd„Z
dd„Zddd„
Zd dd„
Z
d!dd„
Zdd„ZdS)"rz~A list of files built by on exploring the filesystem and filtered by
    applying various patterns to what we find there.
    NcCs>tj
 tj
 |
pt ¡¡
¡
|_|jtj|_d
|_t	ƒ|_
d
S)zd
        Initialise an instance.

        :param base: The base directory to explore under.
        N)ÚosÚpathÚabspathÚnormpathÚgetcwdÚbaseÚsepÚprefixÚallfilesÚsetÚfiles)Úselfr
©rú/build/wlanpi-profiler-7At3M6/wlanpi-profiler-1.0.10/debian/wlanpi-profiler/opt/wlanpi-profiler/lib/python3.7/site-packages/distlib/manifest.pyÚ__init__*s


zManifest.__init__c
Cs°d
dlm
}
m}m}
g|_}|j}|g
}|j}|j}xt|rª|ƒ}t 	|¡
}	xZ|	D]R}
tj
 ||
¡}t |¡
}|j}
|
|
ƒ
rŒ| t
|ƒ
¡

qR||
ƒ
rR||
ƒ
sR||ƒ

qRWq8WdS)zmFind all files under the base and set ``allfiles`` to the absolute
        pathnames of files found.
        r
)ÚS_ISREGÚS_ISDIRÚS_ISLNKN)Ústatrrrrr
ÚpopÚappendrÚlistdirr	ÚjoinÚst_moder)rrrrrÚrootÚstackrÚpushÚnamesÚnameÚfullnamerÚmoderrrÚfindall9s"















zManifest.findallcCs4|
 |j
¡
stj |j|
¡}
|j tj |
¡
¡

d
S)zz
        Add a file to the manifest.

        :param item: The pathname to add. This can be relative to the base.
        N)	Ú
startswithrrr	rr
rÚaddr)rÚitemrrrr)Ts

zManifest.addcCsx|
D]}| |¡

qWd
S)z†
        Add a list of files to the manifest.

        :param items: The pathnames to add. These can be relative to the base.
        N)
r))rÚitemsr*rrrÚadd_many^s

zManifest.add_manyFcsf‡‡
fd
d„‰tˆ
j
ƒ
}|
rJtƒ}x|D]}ˆ|tj |¡
ƒ
q(W||O}dd„tdd„|Dƒ
ƒ
Dƒ
S)z8
        Return sorted files in directory order
        csJ| |
¡

t
 d
|
¡
|
ˆ
jkrFtj |
¡
\}}|dks<t‚
ˆ||ƒ
dS)Nzadd_dir added %s)Úú
/)r)ÚloggerÚdebugr
rr	ÚsplitÚAssertionError)ÚdirsÚ
dÚparentÚ
_)Úadd_dirrrrr7ls







z Manifest.sorted.<locals>.add_dirc
Ssg|]}
tj
j|
Ž‘qSr)rr	r)Ú.0Z
path_tuplerrrú
<listcomp>zsz#Manifest.sorted.<locals>.<listcomp>c
ss|]}
tj
 |
¡
V
qdS)
N)rr	r1)r8r	rrrú	<genexpr>{sz"Manifest.sorted.<locals>.<genexpr>)rrrr	ÚdirnameÚsorted)rZwantdirsÚresultr3Ú
fr)r7rrr<gs








zManifest.sortedc

Cstƒ|_
g|_d
S)zClear all collected files.N)rrr)
rrrrÚclear}s
zManifest.clearcCs„
| |
¡
\}}}}|d
krFx&|D]}|j
|dds t d|¡
q W
n:|dkrnx|D]}|j|dd}qTW
n|dkr x&|D]}|j
|dds|t d|¡
q|Wnà|d	krÆxÖ|D]}|j|dd}q®Wnº|d
krúx°|D] }|j
||dsÔt d||¡
qÔWn†|d
k
r$xz|D]}|j||d}
q
Wn\|dk
rL|j
d|d
s€t d|¡
n4|dk
rt|jd|d
s€t d|¡
ntd|ƒ
‚
dS)av

        Process a directive which either adds some files from ``allfiles`` to
        ``files``, or removes some files from ``files``.

        :param directive: The directive to process. This should be in a format
                     compatible with distutils ``MANIFEST.in`` files:

                     http://docs.python.org/distutils/sourcedist.html#commands
        ÚincludeT)
Úanchorzno files found matching %rÚexcludezglobal-includeFz3no files found matching %r anywhere in distributionzglobal-excludezrecursive-include)
rz-no files found matching %r under directory %rzrecursive-excludeÚgraftNz no directories found matching %rÚprunez4no previously-included directories found matching %rzinvalid action %r)Ú_parse_directiveÚ_include_patternr/ÚwarningÚ_exclude_patternr)rÚ	directiveÚactionÚpatternsÚthedirZ
dirpatternÚpatternÚfoundrrrÚprocess_directive‚sD
































zManifest.process_directivecCs
|
 ¡}t
|ƒ
d
kr,|ddkr,| dd¡
|d}d}}}|dkrxt
|ƒ
dkr`td|ƒ
‚
d	d
„|d
d…Dƒ
}n~|dkr¼t
|ƒ
dkr˜td
|ƒ
‚
t|d
ƒ
}dd
„|dd…Dƒ
}n:|dkrêt
|ƒ
dkrÜtd|ƒ
‚
t|d
ƒ
}ntd|ƒ
‚
||||fS)zŸ
        Validate a directive.
        :param directive: The directive to validate.
        :return: A tuple of action, patterns, thedir, dir_patterns
        rr
)r@rBzglobal-includezglobal-excludezrecursive-includezrecursive-excluderCrDr@N)r@rBzglobal-includezglobal-excluderz$%r expects <pattern1> <pattern2> ...c
Ssg|]}
t|
ƒ
‘qSr)
r)r8Úwordrrrr9êsz-Manifest._parse_directive.<locals>.<listcomp>)zrecursive-includezrecursive-excludeéz*%r expects <dir> <pattern1> <pattern2> ...c
Ssg|]}
t|
ƒ
‘qSr)
r)r8rPrrrr9òs)rCrDz!%r expects a single <dir_pattern>zunknown action %r)r1ÚlenÚinsertrr)rrIÚwordsrJrKrLZdir_patternrrrrEÑs.













zManifest._parse_directiveTcCsTd
}| |
|||¡}|j
dkr&| ¡
x(|j
D]}| |¡
r.|j |¡

d}q.W|S)a…Select strings (presumably filenames) from 'self.files' that
        match 'pattern', a Unix-style wildcard (glob) pattern.

        Patterns are not quite the same as implemented by the 'fnmatch'
        module: '*' and '?'  match non-special characters, where "special"
        is platform-dependent: slash on Unix; colon, slash, and backslash on
        DOS/Windows; and colon on Mac OS.

        If 'anchor' is true (the default), then the pattern match is more
        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
        'anchor' is false, both of these will match.

        If 'prefix' is supplied, then only filenames starting with 'prefix'
        (itself a pattern) and ending with 'pattern', with anything in between
        them, will match.  'anchor' is ignored in this case.

        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
        'pattern' is assumed to be either a string containing a regex or a
        regex object -- no translation is done, the regex is just compiled
        and used as-is.

        Selected strings will be added to self.files.

        Return True if files are found.
        FNT)Ú_translate_patternrr'Úsearchrr))rrMrArÚis_regexrNÚ
pattern_rer$rrrrF
s







zManifest._include_patterncCsFd
}| |
|||¡}x,t
|jƒ
D]}| |¡
r |j |¡

d}q W|S)at
Remove strings (presumably filenames) from 'files' that match
        'pattern'.

        Other parameters are the same as for 'include_pattern()', above.
        The list 'self.files' is modified in place. Return True if files are
        found.

        This API is public to allow e.g. exclusion of SCM subdirs, e.g. when
        packaging source distributions
        FT)rUÚlistrrVÚremove)rrMrArrWrNrXr>rrrrH)
s






zManifest._exclude_patternc
Cs¨
|rt|
t
ƒrt |
¡
S|
Std
kr:| d¡
 d¡
\}}}|
rj| |
¡
}td
krn| |¡
rd| |¡
snt	‚
nd}t 
tj 
|jd¡¡
}	|dk	
rftd
k
rº| d¡
}
| |¡
dt|
ƒ
…}n>| |¡
}| |¡
rØ| |¡
sÜt	‚
|t|ƒ
t|ƒ
t|ƒ
…}tj}tjdk
rd}td
k

r4d|	| 
|d|f¡
}n0|t|ƒ
t|ƒ
t|ƒ
…}d	||	||||f}n8|
ržtd
k

r„d|	|}nd
||	|t|ƒ
d…f}t |¡
S)a
Translate a shell-like wildcard pattern to a compiled regular
        expression.

        Return the compiled regex.  If 'is_regex' true,
        then 'pattern' is directly compiled to a regex (if it's a string)
        or just returned as-is (assumes it's a regex object).
        )rQrr6r-Nú
\z\\ú
^z.*z%s%s%s%s.*%s%sz%s%s%s)Ú
isinstanceÚstrÚreÚcompileÚ_PYTHON_VERSIONÚ_glob_to_reÚ	partitionr(Úendswithr2Úescaperr	rr
rRr)
rrMrArrWÚstartr6ÚendrXr
Z
empty_patternZ	prefix_rerrrrrU=
sB	




























zManifest._translate_patterncCs8t 
|
¡
}tj}tjd
krd}d|}t d||¡}|S)z÷Translate a shell-like glob pattern to a regular expression.

        Return a string containing the regex.  Differs from
        'fnmatch.translate()' in that '*' does not match "special characters"
        (which are platform-specific).
        r[z\\\\z\1[^%s]z((?<!\\)(\\\\)*)\.)ÚfnmatchÚ	translaterrr_Úsub)rrMrXrÚescapedrrrrbt
s





zManifest._glob_to_re)
N)
F)TNF)TNF)TNF)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rr'r)r,r<r?rOrErFrHrUrbrrrrr%s 

	
O/

(



6)rorhÚloggingrr_Úsysr-rÚcompatrÚutilrÚ__all__Ú	getLoggerrlr/r`Ú
MZ_COLLAPSE_PATTERNÚ
SZ_COMMENTED_LINEÚversion_inforaÚobjectrrrrrÚ<module>
s