ó
    Ð]j7O  ã                  óÂ  • % S r SSKJr  SSKrSSKrSSKrSSKrSSKrSSKrSSK	r	SSK
r
SSKJrJr  SSKJr  SSKJr  SSKJrJrJrJr  \" \5      rSqS	\S
'   0 qS\S'   S,S jrS-S jrS.S jrS.S jrS.S jr\R>                  (       a  0 r S\S'   0 r!S\S'   S/S jr"OS/S jr"S/S jr#S0S jr$S1S jr%S.S jr&S2S jr'S3S jr(\\)/S4   S-  r* " S S\RV                  5      r, " S S \,5      r- " S! S"\,5      r. " S# S$\,5      r/S4S% jr0S& V Vs/ s H  u  p\	Rc                  U 5      U4PM     snn r2S5S' jr3  S6       S7S( jjr4 " S) S*5      r5S8S+ jr6\" 5         gs  snn f )9zFile wrangling.é    )ÚannotationsN)ÚCallableÚIterable)Úenv)ÚConfigError)Úhuman_sortedÚisolate_moduleÚ
join_regexÚpluralÚ ÚstrÚRELATIVE_DIRzdict[str, str]ÚCANONICAL_FILENAME_CACHEc                 óæ   • [        [        R                  5      n U R                  [        R                  5      (       d  U [        R                  -   n [        R
                  R                  U 5      q0 qg)z?Set the directory that `relative_filename` will be relative to.N)	Úabs_fileÚosÚcurdirÚendswithÚsepÚpathÚnormcaser   r   )Ú
abs_curdirs    ÚK/home/mande/repo/quber/.venv/lib/python3.13/site-packages/coverage/files.pyÚset_relative_directoryr      sS   € ô
 œ"Ÿ)™)Ó$€JØ×ÑœrŸv™v×&Ñ&à¤"§&¡&Ñ(ˆ
ô —7‘7×#Ñ# JÓ/€Lð  "Ñó    c                 ó   • [         $ )z=Return the directory that `relative_filename` is relative to.)r   © r   r   Úrelative_directoryr   /   s   € äÐr   c                óœ   • [         R                  R                  U 5      nUR                  [        5      (       a  U [        [        5      S n U $ )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)r   r   r   Ú
startswithr   Úlen)ÚfilenameÚfnorms     r   Úrelative_filenamer$   4   s@   € ô �G‰G×Ñ˜XÓ&€EØ×Ñœ×%Ñ%ØœC¤Ó-Ð/Ð0ˆØ€Or   c                ó°  • U [         ;  a²  U n[        R                  R                  U 5      (       dx  [        R                  /[
        R                  -    HR  nUc  M  [        R                  R                  X 5      n [        R                  R                  U5      nU(       d  MP  Un  O   [        U5      nU[         U '   [         U    $ ! [         a    Sn N:f = f)zrReturn a canonical file name for `filename`.

An absolute path with no redundant components and normalized case.

F)
r   r   r   Úisabsr   ÚsysÚjoinÚexistsÚUnicodeErrorr   )r"   Úcfr   Úfr)   s        r   Úcanonical_filenamer-   A   sµ   € ð Ô/Ó/ØˆÜ�w‰w�}‰}˜X×&Ñ&ÜŸ™˜¤c§h¡hÔ.�Ø‘<ÙÜ—G‘G—L‘L Ó0�ð#ÜŸW™WŸ^™^¨AÓ.�F÷ �6Ø�BÙñ /ô �b‹\ˆØ-/Ô  Ñ*Ü# HÑ-Ð-øô $ó #Ø"’Fð#ús   Á;CÃCÃCc                óæ   • [         R                  " U 5      u  pU(       a=  [        R                  " SUR	                  S5      SS9R                  5       SS nSU S3nOS	nXBR                  S
S5      -   $ )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 'z_86bbcbe134d28fd2_c_py'

Úsha3_256zUTF-8F)ÚusedforsecurityNé   Úz_Ú_r   Ú.)ÚntpathÚsplitÚhashlibÚnewÚencodeÚ	hexdigestÚreplace)r"   ÚdirnameÚbasenameÚfpÚprefixs        r   Úflat_rootnamer@   Z   st   € ô Ÿš XÓ.Ñ€GÞÜ�[Š[ØØ�N‰N˜7Ó#Ø!ñ
÷ ‰)‹+�c�rð	ˆð
 �b�T˜�‰àˆØ×$Ñ$ S¨#Ó.Ñ.Ð.r   Ú_ACTUAL_PATH_CACHEzdict[str, list[str]]Ú_ACTUAL_PATH_LIST_CACHEc                óB  • U [         ;   a	  [         U    $ [        R                  R                  U 5      u  pU(       d  UR	                  5       nO·U(       d  UnO­[        U5      nU[        ;   a
  [        U   nO  [        R                  " U5      nU[        U'   [        R                  R                  U5      nU H*  n[        R                  R                  U5      U:X  d  M(  Un  O   [        R                  R                  X5      nU[         U '   U$ ! [         a    / n N�f = f)z:Get the actual path of `path`, including the correct case.)rA   r   r   r6   ÚupperÚactual_pathrB   ÚlistdirÚ	Exceptionr   r(   )r   ÚheadÚtailÚactpathÚfilesÚnormtailr,   s          r   rE   rE   u   sö   € àÔ%Ó%Ü% dÑ+Ð+ä—W‘W—]‘] 4Ó(‰
ˆÞà—j‘j“l‰GÞØ‰Gä˜tÓ$ˆDØÔ.Ó.Ü/°Ñ5‘ðÜŸJšJ tÓ,�Eð
 16Ô'¨Ñ-Ü—w‘w×'Ñ'¨Ó-ˆHÛ�Ü—7‘7×#Ñ# AÓ&¨(Õ2Ø�DÙñ ô —g‘g—l‘l 4Ó.ˆGØ#*Ô˜4Ñ Øˆøô !ó ð ’Eðús   Á7D ÄDÄDc                ó   • U $ )z*The actual path for non-Windows platforms.r   ©r   s    r   rE   rE   —   s   € àˆr   c                óŒ   • [        [        R                  R                  [        R                  R	                  U 5      5      5      $ )z.Return the absolute normalized form of `path`.)rE   r   r   ÚabspathÚrealpathrN   s    r   r   r   œ   s)   € ä”r—w‘w—‘¤r§w¡w×'7Ñ'7¸Ó'=Ó>Ó?Ð?r   c                óÂ   • S HY  nU R                  U[        U 5      -   5      u  p#nU(       d  M,  X!-   n[        R                  R	                  U5      (       d  MV  XT4s  $    g)z–Split a filename into a zipfile / inner name pair.

Only return a pair if the zipfile exists.  No check is made if the inner
name is in the zipfile.

)z.zipz.whlz.eggz.pexz.parN)Ú	partitionr   r   r   r)   )r"   ÚextÚzipbaseÚ	extensionÚinnerÚzipfiles         r   Úzip_locationrY   ¡   sX   € ó 8ˆØ$,×$6Ñ$6°s¼SÀ»]Ñ7JÓ$KÑ!ˆ˜Eßˆ9Ø‘mˆGÜ�w‰w�~‰~˜g×&Ó&Ø�~Ò%ñ 8ð r   c                óp   • [         R                  R                  U 5      (       a  g[        U 5      (       a  gg)z'Determine if a source file path exists.TF)r   r   r)   rY   rN   s    r   Úsource_existsr[   ±   s+   € ä	‡w�w‡~�~�d×ÑØä�D×Ñð àr   c                ó@   • [         R                  R                  U 5      $ )z:Return the string as Python would describe this file name.)r   r   rP   ©r"   s    r   Úpython_reported_filer^   ¾   s   € ä�7‰7�?‰?˜8Ó$Ð$r   c                óh   • [         R                  " U 5      =(       d    [        R                  " U 5      $ )z)Is `filename` an absolute path on any OS?)r5   r&   Ú	posixpathr]   s    r   Úisabs_anywherera   Ã   s   € ä�<Š<˜Ó!×>¤Y§_¢_°XÓ%>Ð>r   c                ó´   • / nU =(       d    /  HF  nUR                  U5        UR                  S5      (       a  M,  UR                  [        U5      5        MH     U$ )a  Prepare the file patterns for use in a `GlobMatcher`.

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.

)Ú*Ú?)Úappendr    r   )ÚpatternsÚpreppedÚps      r   Úprep_patternsri   È   sK   € ð €GØ�^˜Š^ˆØ�‰�qÔØ�|‰|˜J×'Ó'Ø�N‰Nœ8 A›;Ö'ñ ð €Nr   c                  óh   • \ rS rSrSrS
S jrSS jrSS jr\R                  SS j5       r
SS jrSrg	)ÚMatcheréÝ   zCommon behavior for matchers.c                óŠ   • Xl         X l        U(       a0  U" U SU  35        U R                  5        H  nU" SU 35        M     g g )Nz
 matching z    )ÚstrsÚnameÚinfo)Úselfrn   ro   ÚcaptionÚdebugÚinfs         r   Ú__init__ÚMatcher.__init__à   sE   € ØŒ	ØŒ	ÞÙ�W�I˜Z¨ vÐ.Ô/Ø—y‘y–{�Ù˜˜S˜E�lÖ#ò #ð r   c                ó’   • [        U R                  5      nU R                  R                   SU R                  < S[        US5       3$ )NÚ Úitem)r!   rn   Ú	__class__Ú__name__ro   r   )rq   Úns     r   Ú__str__ÚMatcher.__str__è   s=   € Ü�—	‘	‹NˆØ—.‘.×)Ñ)Ð*¨!¨D¯I©I©=¸¼&ÀÀFÓ:KÐ9LÐMÐMr   c                ól   • SU R                   R                   SU R                   SU R                  < S3$ )NÚ<rx   Ú>)rz   r{   ro   rn   ©rq   s    r   Ú__repr__ÚMatcher.__repr__ì   s0   € Ø�4—>‘>×*Ñ*Ð+¨1¨T¯Y©Y¨K°q¸¿¹¹ÀQÐGÐGr   c                ó   • g)zDoes this string match?Nr   )rq   Úss     r   ÚmatchÚMatcher.matchï   s   � r   c                ó   • U R                   $ )z4A list of strings for displaying when dumping state.)rn   r‚   s    r   rp   ÚMatcher.infoó   s   € à�y‰yÐr   )ro   rn   N)
rn   ú	list[str]ro   r   rr   r   rs   ÚDebugFnÚreturnÚNone©r�   r   )r†   r   r�   Úbool)r�   r‹   )r{   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__ru   r}   rƒ   ÚabcÚabstractmethodr‡   rp   Ú__static_attributes__r   r   r   rk   rk   Ý   s5   † Ù'ô$ôNôHð 	×Ñó&ó ð&÷r   rk   c                  óV   ^ • \ rS rSrSr   S         SU 4S jjjrSS jrSrU =r$ )	ÚTreeMatcheréø   zç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.
c                ó  >• [        U5      n[        U5      U l        [        TU ]  U R                  X#US9  / U l        U HE  n[        U5      nXv:w  a  U(       a  U" SU< SU< 35        U R
                  R                  U5        MG     g )N©ro   rr   rs   z        Normalized ú to )Úlistr   Úoriginal_pathsÚsuperru   Úpathsr   re   )	rq   r¡   ro   rr   rs   Ú
paths_listrh   Úaprz   s	           €r   ru   ÚTreeMatcher.__init__   s   ø€ ô ˜%“[ˆ
Ü*¨:Ó6ˆÔÜ‰Ñ˜×,Ñ,°4ÐPUÐÑVØˆŒ
ÛˆAÜ˜!“ˆBØ‹wž5ÙÐ+¨A©5°°R±FÐ;Ô<Ø�J‰J×Ñ˜bÖ!ò	 r   c                óÂ   • [        U5      nU R                   HD  nUR                  U5      (       d  M  X:X  a    gU[        U5         [        R
                  :X  d  MD    g   g)z1Does `fpath` indicate a file in one of our trees?TF)r   r¡   r    r!   r   r   )rq   Úfpathrh   s      r   r‡   ÚTreeMatcher.match  sN   € ä˜“ˆØ—”ˆAØ×Ñ ×"Ó"Ø“:áØœ˜Q›‘=¤B§F¡FÕ*áñ ð r   )rŸ   r¡   ©Úunknownr   N)
r¡   úIterable[str]ro   r   rr   r   rs   rŒ   r�   rŽ   ©r¦   r   r�   r�   ©	r{   r‘   r’   r“   r”   ru   r‡   r—   Ú__classcell__©rz   s   @r   r™   r™   ø   sW   ø† ñð ØØð"àð"ð ð"ð ð	"ð
 ð"ð 
÷"ð "÷"ò r   r™   c                  óV   ^ • \ rS rSrSr   S         SU 4S jjjrSS jrSrU =r$ )	ÚModuleMatcheri  z A matcher for modules in a tree.c                óX   >• [        U5      U l        [        TU ]  U R                  X#US9  g )Nrœ   )rž   Úmodulesr    ru   )rq   Úmodule_namesro   rr   rs   rz   s        €r   ru   ÚModuleMatcher.__init__"  s)   ø€ ô ˜LÓ)ˆŒÜ‰Ñ˜Ÿ™¨DÈÐÒOr   c                ó    • U(       d  gU R                    H6  nUR                  U5      (       d  M  X:X  a    gU[        U5         S:X  d  M6    g   g)z<Does `module_name` indicate a module in one of our packages?FTr4   )r²   r    r!   )rq   Úmodule_nameÚms      r   r‡   ÚModuleMatcher.match,  sI   € æØà—”ˆAØ×%Ñ% a×(Ó(ØÓ#ÙØœs 1›vÑ&¨#Õ-áñ ð r   )r²   r¨   )
r³   rª   ro   r   rr   r   rs   rŒ   r�   rŽ   )r¶   r   r�   r�   r¬   r®   s   @r   r°   r°     s\   ø† Ù*ð
 ØØðPà#ðPð ðPð ð	Pð
 ðPð 
÷Pð P÷ò r   r°   c                  óV   ^ • \ rS rSrSr   S         SU 4S jjjrSS jrSrU =r$ )	ÚGlobMatcheri<  z)A matcher for files by file name pattern.c                ó¦   >• [        U5      U l        [        TU ]  U R                  X#US9  [	        U R                  [
        R                  S9U l        g )Nrœ   )Úcase_insensitive)rž   Úpatsr    ru   Úglobs_to_regexr   ÚWINDOWSÚre)rq   r½   ro   rr   rs   rz   s        €r   ru   ÚGlobMatcher.__init__?  s>   ø€ ô ˜“JˆŒ	Ü‰Ñ˜Ÿ™¨ÀeÐÑLÜ  §¡¼S¿[¹[ÑIˆ�r   c                ó<   • U R                   R                  U5      SL$ )z1Does `fpath` match one of our file name patterns?N)rÀ   r‡   )rq   r¦   s     r   r‡   ÚGlobMatcher.matchJ  s   € à�w‰w�}‰}˜UÓ#¨4Ð/Ð/r   )r½   rÀ   r¨   )
r½   rª   ro   r   rr   r   rs   rŒ   r�   rŽ   r«   r¬   r®   s   @r   rº   rº   <  s\   ø† Ù3ð
 ØØð	Jàð	Jð ð	Jð ð		Jð
 ð	Jð 
÷	Jð 	J÷0ò 0r   rº   c                óp   • [         R                  " SU 5      =n(       a  US   nU$ [        R                  nU$ )z?Find the path separator used in this string, or os.sep if none.ú[\\/]r   )rÀ   Úsearchr   r   )r†   Ú	sep_matchÚthe_seps      r   r   r   O  s8   € ä—I’I˜h¨Ó*Ð*€yÕ*Ø˜A‘,ˆð €Nô —&‘&ˆØ€Nr   ))z\*\*\*+N)z
[^/]+\*\*+N)z
\*\*+[^/]+N)z	\*\*/\*\*N)z^\*+/ú(.*[/\\\\])?)z/\*+$z	[/\\\\].*)z\*\*/rÉ   )Ú/z[/\\\\])z\*z	[^/\\\\]*)z\?z[^/\\\\])z\[.*?\]ú\g<0>)z[a-zA-Z0-9_-]+rË   )z[\[\]]N)r4   z\\\g<0>c                ó~  • U R                  SS5      n SU ;  a  SU  3n / nSnU[        U 5      :  a}  [         Hb  u  p4UR                  XS9=n(       d  M  Uc  [	        SUS   < 35      eUR                  UR                  U5      5        UR                  5       n  O   U[        U 5      :  a  M}  SR                  U5      $ )z.Convert a file-path glob pattern into a regex.Ú\rÊ   z**/r   )ÚposzFile pattern can't include r   )	r;   r!   ÚG2RX_TOKENSr‡   r   re   ÚexpandÚendr(   )ÚpatternÚpath_rxrÎ   ÚrxÚsubr·   s         r   Ú_glob_to_regexrÖ   n  s¼   € ð �o‰o˜d CÓ(€GØ
�'ÓØ˜�y�/ˆØ€GØ
€CØ
”�G“Ó
ß"‰GˆBØ—H‘H˜W�HÐ.Ð.ˆq×.Ø‘;Ü%Ð(CÀAÀaÁDÁ8Ð&LÓMÐMØ—‘˜qŸx™x¨›}Ô-Ø—e‘e“g�Ùñ #ð ”�G“Õ
ð �7‰7�7ÓÐr   c                ó²   • SnU(       a  U[         R                  -  n[        [        [        U 5      5      nU(       d  SU S3n[         R
                  " XCS9nU$ )aS  Convert glob 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 the pattern has no slash or backslash, then it is interpreted as
matching a file name anywhere it appears in the tree.  Otherwise, the glob
pattern must match the whole file path.

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.

r   z(?:z)\Z)Úflags)rÀ   Ú
IGNORECASEr
   ÚmaprÖ   Úcompile)rf   r¼   ÚpartialrØ   rÔ   Úcompileds         r   r¾   r¾   �  sN   € ð* €EÞØ”—‘ÑˆÜ	”Cœ¨Ó1Ó	2€BÞØ�B�4�sˆ^ˆÜ�zŠz˜"Ñ*€HØ€Or   c                  óX   • \ rS rSrSr  S	     S
S jjrSS jrSS jr\4SS jjr	Sr
g)ÚPathAliasesi   aq  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.

Nc                óN   • / U l         U=(       d    S U l        X l        SU l        g )Nc                ó   • g)Nr   r   )Úmsgs    r   Ú<lambda>Ú&PathAliases.__init__.<locals>.<lambda>³  s   € ¨qr   F)ÚaliasesÚdebugfnÚrelativeÚpprinted)rq   ræ   rç   s      r   ru   ÚPathAliases.__init__¬  s%   € ð @BˆŒØ×1¡=ˆŒØ ŒØˆ�r   c           	     ó¼   • U R                  SU R                   S35        U R                   H-  u  pnU R                  SU< SU< SUR                  < 35        M/     g)z;Dump the important parts of the PathAliases, for debugging.zAliases (relative=z):z Rule: ú -> ú using regex N)ræ   rç   rå   rÒ   )rq   Úoriginal_patternÚregexÚresults       r   ÚpprintÚPathAliases.pprint·  sY   € à�‰Ð)¨$¯-©-¨¸Ð;Ô<Ø/3¯|¬|Ñ+Ð VØ�L‰L˜7Ð#3Ñ"6°d¸6¹*ÀMÐRW×R_ÑR_ÑQbÐcÖdò 0<r   c                óì  • Un[        U5      n[        U5      S:”  a  UR                  S5      nUR                  S5      (       a  [	        S5      eU R
                  (       d3  UR                  S5      (       d  [        X-   5      (       d  [        U5      nUR                  U5      (       d  X-  n[        U/SSS9n[        U5      nUR                  S5      U-   nU R                  R                  X5U45        g)a¾  Add the `pattern`/`result` pair to the list of aliases.

`pattern` is an `glob`-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.

é   z\/rc   z$Pattern must not end with wildcards.T)r¼   rÜ   N)r   r!   Úrstripr   r   rç   r    ra   r   r¾   rå   re   )rq   rÒ   rï   rí   Úpattern_seprî   Ú
result_seps          r   ÚaddÚPathAliases.add½  sÞ   € ð #ÐÜ˜'“lˆäˆw‹<˜!ÓØ—n‘n UÓ+ˆGð ×Ñ˜C× Ñ ÜÐDÓEÐEð �}�}Ø×%Ñ% c×*Ñ*´>À'ÑBW×3XÑ3XÜ" 7Ó+�Ø×Ñ ×,Ñ,ØÑ"ˆGô  ˜y¸4ÈÑNˆô ˜“[ˆ
Ø—‘˜uÓ%¨
Ñ2ˆØ�‰×ÑÐ-°fÐ=Õ>r   c           
     ó  ^• U R                   (       d  U R                  5         SU l         U R                   GH  u  p4nUR                  U5      =n(       d  M!  UR	                  US   U5      nUR	                  [        U5      [        U5      5      nU R                  (       d  [        U5      nUR                  S5      =(       a    [        U5      S:„  nUR                  S5      (       a  U(       d  USS nU" U5      (       d#  U R                  SU< SU< SU< S	3S
-   5        Mî  U R                  SU< SU< SU< S3SU< 3-   5        Us  $    U R                  (       a  [        U5      nU R                  (       að  [        U5      (       dà  [        R                  " SU5      n	[        U	5      S:”  aº  U	S   n
SU
 3mS[        R                  " U
5       S3nU
 [         R
                   3n[#        U4S jU R                   5       5      (       d^  U R                  ST< SU< SU< 35        U R                  R%                  T[        R&                  " U5      U45        U R)                  XS9$ U R                  SU< S35        U$ )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.

`exists` is a function to determine if the resulting path actually
exists.

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.

Tr   )z./z.\é   NzRule z	 changed r�   rx   zwhich doesn't exist, continuingzMatched path z	 to rule rë   z, z
producing z[/\\]ró   z*/z^(.*[\\/])?rÅ   c              3  ó4   >#   • U  H  u  n  o!T:H  v •  M     g 7f)Nr   )Ú.0rh   r3   rÒ   s      €r   Ú	<genexpr>Ú"PathAliases.map.<locals>.<genexpr>  s   øé € ÐD²|©G¨A¨q°! ž<²|ùs   ƒzGenerating rule: rì   )r)   zNo rules match, path z is unchanged)rè   rð   rå   r‡   r;   r   rç   r-   r    r!   ræ   r$   ra   rÀ   r6   Úescaper   Úanyre   rÛ   rÚ   )rq   r   r)   rí   rî   rï   r·   r8   Ú	dot_startÚpartsÚdir1Ú	regex_patrÒ   s               @r   rÚ   ÚPathAliases.mapä  s8  ø€ ð& �}�}Ø�K‰KŒMØ ˆDŒMà/3¯|­|Ñ+Ð VØ—K‘K Ó%Ð%ˆq×%Ø—l‘l 1 Q¡4¨Ó0�Ø—k‘k¤# d£)¬S°«[Ó9�Ø—}—}Ü,¨SÓ1�CØ"×-Ñ-¨mÓ<×PÄÀVÃÈqÁ�	Ø—>‘> -×0Ñ0¾Ø˜a˜b˜'�CÙ˜c—{‘{Ø—L‘LØÐ 0Ñ3°9¸T¹HÀDÈÉÈqÐQØ;ñ<ôñ Ø—‘Ø# D¡8¨9Ð5EÑ4HÈÈVÉJÐVXÐYØ" 3¡'Ð*ñ+ôð ’
ñ' 0<ð. �=�=Ü$ TÓ*ˆDà�=�=¤°×!5Ñ!5ä—H’H˜X tÓ,ˆEÜ�5‹z˜A‹~Ø˜Q‘x�Ø˜t˜f˜+�Ø*¬2¯9ª9°T«?Ð*;¸5ÐA�	Ø ˜6¤"§&¡& Ð*�äÔD°t·|²|ÓD×DÑDØ—L‘LØ+¨G©;°d¸6¹*ÀMÐR[ÑQ^Ð_ôð —L‘L×'Ñ'¨´"·*²*¸YÓ2GÈÐ(PÔQØŸ8™8 D˜8Ð8Ð8à�‰Ð,¨T©H°MÐBÔCØˆr   )rå   ræ   rè   rç   )NF)ræ   zCallable[[str], None] | Nonerç   r�   r�   rŽ   ©r�   rŽ   )rÒ   r   rï   r   r�   rŽ   )r   r   r)   zCallable[[str], bool]r�   r   )r{   r‘   r’   r“   r”   ru   rð   r÷   r[   rÚ   r—   r   r   r   rß   rß      sN   † ñ	ð 15Øð	à-ð	ð ð	ð 
õ		ôeô%?ðN >K÷ Bñ Br   rß   c              #  ó(  #   • [        [        R                  " U 5      5       Hk  u  nu  p4nU(       d  US:”  a  SU;  a  USS2	 M#  U HB  n[        R                  " SU5      (       d  M!  [        R
                  R                  X65      v •  MD     Mm     g7f)aT  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.

If `include_namespace_packages` is True, then the check for __init__.py
files is skipped.

Files with strange characters are skipped, since they couldn't have been
imported, and are probably editor side-files.

r   z__init__.pyNz^[^.#~!$@%^&*()+=,]+\.pyw?$)Ú	enumerater   ÚwalkrÀ   r‡   r   r(   )r<   Úinclude_namespace_packagesÚiÚdirpathÚdirnamesÚ	filenamesr"   s          r   Úfind_python_filesr  )  sx   é € ô  .7´r·w²w¸wÓ7GÖ-HÑ)ˆÑ)ˆG˜yÞ)Ø�1‹u˜¨iÓ7ð šQ�KÙÛ!ˆHô �xŠxÐ6¸×AÓAÜ—g‘g—l‘l 7Ó5Ô5ó "ò .Iùs   ‚A"BÁ(*Br  r�   )r"   r   r�   r   )r   r   r�   r   )r"   r   r�   ztuple[str, str] | None)r   r   r�   r�   )r"   r   r�   r�   )rf   rª   r�   r‹   )r†   r   r�   r   )rÒ   r   r�   r   )FF)rf   rª   r¼   r�   rÜ   r�   r�   zre.Pattern[str])r<   r   r
  r�   r�   rª   )7r”   Ú
__future__r   r•   r7   r5   r   Úos.pathr`   rÀ   r'   Úcollections.abcr   r   Úcoverager   Úcoverage.exceptionsr   Úcoverage.miscr   r	   r
   r   r   Ú__annotations__r   r   r   r$   r-   r@   r¿   rA   rB   rE   r   rY   r[   r^   ra   ri   r   rŒ   ÚABCrk   r™   r°   rº   r   rÛ   rÏ   rÖ   r¾   rß   r  )rÔ   rÕ   s   00r   Ú<module>r     s�  ðò å "ã 
Û Û Û 	Û Û Û 	Û 
ß .å Ý +ß JÓ Já�BÓ€ð €ˆcÓ Ø+-Ð ˜.Ó -ô"ô$ô

ô.ô2/ð. ‡;‡;Ø)+Ð˜Ó+Ø46ÐÐ1Ó6õôDô
@ô
ô 
ô%ô
?ô
ð$ �C�5˜$�;Ñ
 $Ñ
&€ôˆc�g‰gô ô6$�'ô $ôN�Gô ô:0�'ô 0ô&ñ5ô ò 5©¨�—
‘
˜2“ Ó$ñ 5ò €ô&ð* #ØðØðàðð ðð õ	÷>Fñ FôR6ñ@ Õ ùó]s   ÄE