+ UBiX(Rt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RIH t H t ^RI Ht^RIHt^RIHtHtHtH t HtHtH t HtHtHtHtHtHtHtHt^RIHt]P@R28d]]!]]!,3,t"M ]]!]3,t"]!R]"R7t#]PH]PJ3Uu.uF"pV'gK V]PH8wgK VNK$ upt&/t'R R lt(R R lt)R3R Rllt*RRlt+RRlt,R4RRllt-RRlt.R4RRllt/R4Rlt0RRlt1RRlt2RRlt3R3R R!llt4R3R"R#llt5R3R$R%llt6!R&R']74t8!R(R)]74t9]!R*R+7!R,R-]]#,44t:!R.R/];4t<!R0R1];4t=R#uupi)5zC This module provides utility methods for dealing with path-specs. N) CollectionIterable) dataclass)PathLike)AnyAnyStrCallablerDictGenericrIteratorListOptionalSequenceSetTupleTypeVarUnion)PatternTStrPath)boundcDV^8dQhR\PR\/#)pathreturn)pathlibPathstr)formats"2/usr/lib/python3.14/site-packages/pathspec/util.py __annotate__rDs#cv\V4pVP4'dV\P, pV#)a. Appends the path separator to the path if the path is a directory. This can be used to aid in distinguishing between directories and files on the file-system by relying on the presence of a trailing path separator. *path* (:class:`pathlib.Path`) is the path to use. Returns the path (:class:`str`). )ris_dirossep)rstr_paths& rappend_dir_sepr&Ds+ IKKMM bff(r c V^8dQhR\\\\3,,R\R\\ \ ,\ \,3,/#rpatternsfiler)rrintrrr bool)rs"rrrVsF E#w,' (  8D>8C= ()r cRpRpVF8wrEVPfKVPV4fK*VPpTpK: W#3#)a Check the file against the patterns. *patterns* (:class:`~collections.abc.Iterable`) yields each indexed pattern (:class:`tuple`) which contains the pattern index (:class:`int`) and actual pattern (:class:`~pathspec.pattern.Pattern`). *file* (:class:`str`) is the normalized file path to be matched against *patterns*. Returns a :class:`tuple` containing whether to include *file* (:class:`bool` or :data:`None`), and the index of the last matched pattern (:class:`int` or :data:`None`). Ninclude match_file)r)r* out_include out_indexindexpatterns&& rcheck_match_filer5VsM$ $ ^U __ W%7%7%=%I;9 r c V^8dQhR\\,R\\,R\\,R\ \R3,/#)rr)files all_matchesr MatchDetail)rrrr r,r )rs"rrrrsG++ G + +tn+ #}  +r c\V\4'dTM \V4p/pVFpVPfKVP V4pVP'dbVFYpWt9dCV'd$WG,P P V4K4WTV,P ^&KK\V.4WG&K[ KVFpWHK K V#)a Matches the files to the patterns, and returns which patterns matched the files. *patterns* (:class:`~collections.abc.Iterable` of :class:`~pathspec.pattern.Pattern`) contains the patterns to use. *files* (:class:`~collections.abc.Iterable` of :class:`str`) contains the normalized file paths to be matched against *patterns*. *all_matches* (:class:`bool` or :data:`None`) is whether to return all matches patterns (:data:`True`), or only the last matched pattern (:data:`False`). Default is :data:`None` for :data:`False`. Returns the matched files (:class:`dict`) which maps each matched file (:class:`str`) to the patterns that matched in order (:class:`.MatchDetail`). ) isinstanceCollectionTypelistr/matchr)appendr9) r)r7r8 all_files return_filesr4 result_files result_filer*s &&& rdetailed_match_filesrDrs,!77UT%[W __ -- *< ooo# #  ))009/6K ))!,"-wi"8l$  !& r c~V^8dQhR\\,R\\\\3,,/#)rr)r)rrr rr+)rs"rrrs/ G  %W r cn\V4UUu.uFwrVPfKW3NK upp#uuppi)a Filters out null-patterns. *patterns* (:class:`Iterable` of :class:`.Pattern`) contains the patterns. Returns a :class:`list` containing each indexed pattern (:class:`tuple`) which contains the pattern index (:class:`int`) and the actual pattern (:class:`~pathspec.pattern.Pattern`). ) enumerater/)r)__index__pats& r_filter_check_patternsrJs<"(+ +ng ]]7+  s11c0V^8dQhR\R\/#)rvaluer)rr,)rs"rrrsPPPPr ch\V\4;'d\V\\34'*#)z Check whether the value is an iterable (excludes strings). *value* is the value to check, Returns whether *value* is a iterable (:class:`bool`). )r; IterableTyperbytes)rLs&r _is_iterablerPs' 5,'OO 53,0O,OOr c V^8dQhR\R\\\.R3,,R\\,R\ R,/#)rrooton_errorN follow_linksr TreeEntry)StrPathr rOSErrorr,r )rs"rrrsO [ [ [ HgY_- . [~ [k [r c#"Ve"\V4'g\RV: R24hVfRp\\PP V4R/W4RjxL R#L5i)a Walks the specified directory for all files and directories. *root* (:class:`str` or :class:`os.PathLike`) is the root directory to search. *on_error* (:class:`~collections.abc.Callable` or :data:`None`) optionally is the error handler for file-system exceptions. It will be called with the exception (:exc:`OSError`). Reraise the exception to abort the walk. Default is :data:`None` to ignore file-system exceptions. *follow_links* (:class:`bool` or :data:`None`) optionally is whether to walk symbolic links that resolve to directories. Default is :data:`None` for :data:`True`. Raises :exc:`RecursionError` if recursion is detected. Returns an :class:`~collections.abc.Iterator` yielding each file or directory entry (:class:`.TreeEntry`) relative to *root*. Nz on_error: is not callable.T)callable TypeError_iter_tree_entries_nextr#rabspathrRrSrTs&&&riter_tree_entriesr`sX4 (!3!3Ih\):;<<, #BGGOOD$92r8 ZZZsAA%A#A%c V^8dQhR\R\R\\\3,R\\.R3,R\R\ R,/#) r root_fulldir_relmemorSNrTrrU)rr rrWr,r )rs"rrrsdNN N N CH~N WItO $ N  N k Nr c #"\PPW4p\PPV4pWb9dWV&M\ WbV,VR7h\P !V4;_uu_4pVFp\PPWP 4p VPRR7p TP4'dTP4p MT p TPTR7'd1\TP YT 4x\Y Y#T4RjxL KTP4'gTP4'gK\TP YT 4xK RRR4W&R# \dp Te T!T 4Rp ? EK&Rp ? ii;i \dp Te T!T 4Rp ? EKLRp ? ii;iL +'giLb;i5i)ad Scan the directory for all descendant files. *root_full* (:class:`str`) the absolute path to the root directory. *dir_rel* (:class:`str`) the path to the directory to scan relative to *root_full*. *memo* (:class:`dict`) keeps track of ancestor directories encountered. Maps each ancestor real path (:class:`str`) to relative path (:class:`str`). *on_error* (:class:`~collections.abc.Callable` or :data:`None`) optionally is the error handler for file-system exceptions. *follow_links* (:class:`bool`) is whether to walk symbolic links that resolve to directories. Yields each entry (:class:`.TreeEntry`). ) real_path first_path second_pathF)follow_symlinksN)r#rjoinrealpathRecursionErrorscandirnamestatrW is_symlinkr"rUr]is_file) rbrcrdrSrTdir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats &&&&& rr]r]s6 GGLL , GG  X &  x.8nRYZZjjihggll7MM28 u5J Y Ioolo33 HMM8 CC&yDLYYYh1133 HMM8 CC?P ^A   a[   qk Z;sA/G.F GF/'G)G+G ,GG G= G* F,  F' G'F, ,G/ G : G G G G G' "G*c V^8dQhR\R\\\.R3,,R\\,R\ \ ,/#)rrRrSNrTr)rVr rrWr,r r)rs"rrr3sH HgY_- .~c] r c#"\WVR7F*pVPV4'dKVPxK, R#5i)a Walks the specified directory for all files. *root* (:class:`str` or :class:`os.PathLike`) is the root directory to search for files. *on_error* (:class:`~collections.abc.Callable` or :data:`None`) optionally is the error handler for file-system exceptions. It will be called with the exception (:exc:`OSError`). Reraise the exception to abort the walk. Default is :data:`None` to ignore file-system exceptions. *follow_links* (:class:`bool` or :data:`None`) optionally is whether to walk symbolic links that resolve to directories. Default is :data:`None` for :data:`True`. Raises :exc:`RecursionError` if recursion is detected. Returns an :class:`~collections.abc.Iterator` yielding the path to each file (:class:`str`) relative to *root*. rSrTN)r`r"r)rRrSrTentrys&&& riter_tree_filesr~3s24 lSU l # # Ts %AAcV\P!R\^R7\WVR7#)zd DEPRECATED: The :func:`.iter_tree` function is an alias for the :func:`.iter_tree_files` function. zCutil.iter_tree() is deprecated. Use util.iter_tree_files() instead. stacklevelr|)warningswarnDeprecationWarningr~r_s&&&r iter_treerRs'  G1& lKKr cTV^8dQhR\R\\.\3,/#)rrnrrrrr)rs"rrr]s& # # #6(G*;!< #r c\V,#)z Lookups a registered pattern factory by name. *name* (:class:`str`) is the name of the pattern factory. Returns the registered pattern factory (:class:`~collections.abc.Callable`). If no pattern factory is registered, raises :exc:`KeyError`. )_registered_patterns)rns&rlookup_patternr]s T""r cRV^8dQhR\\,R\R\/#r()rrrr,)rs"rrris&'*#$r c~RpVF4pVPfKVPV4fK(VPpK6 V#)a0 Matches the file to the patterns. *patterns* (:class:`~collections.abc.Iterable` of :class:`~pathspec.pattern.Pattern`) contains the patterns to use. *file* (:class:`str`) is the normalized file path to be matched against *patterns*. Returns :data:`True` if *file* matched; otherwise, :data:`False`. Fr.)r)r*matchedr4s&& rr0r0is= W __ W%7%7%=%I __7 r c~V^8dQhR\\,R\\,R\\,/#)rr)r7r)rrrr)rs"rrr}s3 G   Xr c\P!\ R\ R2\^R7VUu.uFq"PfKVNK pp\ 4pVF'p\ W54'gKVPV4K) V#uupi)a DEPRECATED: This is an old function no longer used. Use the :func:`~pathspec.util.match_file` function with a loop for better results. Matches the files to the patterns. *patterns* (:class:`~collections.abc.Iterable` of :class:`~pathspec.pattern.Pattern`) contains the patterns to use. *files* (:class:`~collections.abc.Iterable` of :class:`str`) contains the normalized file paths to be matched against *patterns*. Returns the matched files (:class:`set` of :class:`str`). z".match_files() is deprecated. Use z-.match_file() with a loop for better results.r)rr__name__rr/setr0add)r)r7rI use_patternsrAr*s&& r match_filesr}s$  J0 ; 1& %-JH5 HJ T ##D Ks BBchV^8dQhR\R\\\,,R\/#)rr* separatorsr)rVr rr)rs"rrrs/%%% jo &% %r cVf\p\P!V4pVF#pVPV\P 4pK% VP R4'd VR,pV#VP R4'd VR,pV#)an Normalizes the file path to use the POSIX path separator (i.e., ``"/"``), and make the paths relative (remove leading ``"/"``). *file* (:class:`str` or :class:`os.PathLike`) is the file path. *separators* (:class:`~collections.abc.Collection` of :class:`str`; or ``None``) optionally contains the path separators to normalize. This does not need to include the POSIX path separator (``"/"``), but including it will not affect the results. Default is ``None`` for ``NORMALIZE_PATH_SEPS``. To prevent normalization, pass an empty container (e.g., an empty tuple ``()``). Returns the normalized file path (:class:`str`). /:NNz./:rNN)NORMALIZE_PATH_SEPSr#fspathreplace posixpathr$ startswith)r*r norm_filer$s&& rnormalize_filers("*))D/ SY]]3) m)  4  m)r c V^8dQhR\\,R\\\,,R\ \\ \,3,/#)rr7rr)rrVr rrr r )rs"rrrsB""" jo &" #tG} "r c\P!R\^R7/pVF3p\W1R7pWB9dW$,P V4K.V.W$&K5 V#)a DEPRECATED: This function is no longer used. Use the :func:`.normalize_file` function with a loop for better results. Normalizes the file paths to use the POSIX path separator. *files* (:class:`~collections.abc.Iterable` of :class:`str` or :class:`os.PathLike`) contains the file paths to be normalized. *separators* (:class:`~collections.abc.Collection` of :class:`str`; or :data:`None`) optionally contains the path separators to normalize. See :func:`normalize_file` for more information. Returns a :class:`dict` mapping each normalized file path (:class:`str`) to the original file paths (:class:`list` of :class:`str` or :class:`os.PathLike`). z_util.normalize_files() is deprecated. Use util.normalize_file() with a loop for better results.r)r)rrrrr?)r7r norm_filesrrs&& rnormalize_filesrs^* $1&  TT9) % 6:  r czV^8dQhR\R\\.\3,R\\ ,RR/#)rrnpattern_factoryoverriderN)rrrrr r,)rs"rrrs@.. .F8W,-. D>. .r c\V\4'g\RV: R24h\V4'g\RV: R24hV\9d V'g\ V\V,4hV\V&R#)a: Registers the specified pattern factory. *name* (:class:`str`) is the name to register the pattern factory under. *pattern_factory* (:class:`~collections.abc.Callable`) is used to compile patterns. It must accept an uncompiled pattern (:class:`str`) and return the compiled pattern (:class:`.Pattern`). *override* (:class:`bool` or :data:`None`) optionally is whether to allow overriding an already registered pattern under the same name (:data:`True`), instead of raising an :exc:`AlreadyRegisteredError` (:data:`False`). Default is :data:`None` for :data:`False`. zname:z is not a string.zpattern_factory:rYN)r;rr\r[rAlreadyRegisteredError)rnrrs&&&rregister_patternrsq( 4E$!2344!!$_$77HIJJ  t%9$%?@@-dr caa]tRtRtoRtV3RlV3Rllt]V3RlRl4t]V3RlRl4t]V3R lR l4t R t Vt V;t #) ri zy The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory is registered under a name already in use. cB<V^8dQhRS[RS[S[.S[3,RR/#)rrnrrNr)r __classdict__s"rr#AlreadyRegisteredError.__annotate__s: F F  FVHg-. F Fr c .<\\V` W4R#)z Initializes the :exc:`AlreadyRegisteredError` instance. *name* (:class:`str`) is the name of the registered pattern. *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. N)superr__init__)selfrnr __class__s&&&rrAlreadyRegisteredError.__init__s.tEr c <V^8dQhRS[/#rrr)rrs"rrr!scr c PRPVPVPR7#)0 *message* (:class:`str`) is the error message. zG{name!r} is already registered for pattern factory:{pattern_factory!r}.)rnr)rrnrrs&rmessageAlreadyRegisteredError.message s. S Y Y '' Z r c <V^8dQhRS[/#rr)rrs"rrr+s3r c (VP^,#)z> *name* (:class:`str`) is the name of the registered pattern. argsrs&rrnAlreadyRegisteredError.name*s 1r c8<V^8dQhRS[S[.S[3,/#r)rrr)rrs"rrr2s hx'89r c (VP^,#)z[ *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrs&rr&AlreadyRegisteredError.pattern_factory1 1r ) r __module__ __qualname____firstlineno____doc__rpropertyrrnr__static_attributes____classdictcell__ __classcell__rrs@@rrr sW F F       r rcaa]tRtRtoRtV3RlV3Rllt]V3RlRl4t]V3RlRl4t]V3R lR l4t ]V3R lR l4t R t Vt V;t #)rli:zK The :exc:`RecursionError` exception is raised when recursion is detected. c0<V^8dQhRS[RS[RS[RR/#)rrfrgrhrNr)rrs"rrRecursionError.__annotate__@s9KK KK K  Kr c 0<\\V` WV4R#)a Initializes the :exc:`RecursionError` instance. *real_path* (:class:`str`) is the real path that recursion was encountered on. *first_path* (:class:`str`) is the first path encountered for *real_path*. *second_path* (:class:`str`) is the second path encountered for *real_path*. N)rrlr)rrfrgrhrs&&&&rrRecursionError.__init__@s$&ykJr c <V^8dQhRS[/#rr)rrs"rrrUsr c (VP^,#)zr *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrs&rrgRecursionError.first_pathTrr c <V^8dQhRS[/#rr)rrs"rrr]scr c fRPVPVPVPR7#)rzDReal path {real!r} was encountered at {first!r} and then {second!r}.)realfirstsecond)rrfrgrhrs&rrRecursionError.message\s5 P V V      W r c <V^8dQhRS[/#rr)rrs"rrrhsr c (VP^,#)zP *real_path* (:class:`str`) is the real path that recursion was encountered on. rrs&rrfRecursionError.real_pathgrr c <V^8dQhRS[/#rr)rrs"rrrps#r c (VP^,#)zt *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rrs&rrhRecursionError.second_pathorr r)rrrrrrrrgrrfrhrrrrs@@rrlrl:sk KK(        r rlT)frozenc:a]tRtRtoRtRtV3RltRtVtR#) CheckResultixzb The :class:`CheckResult` class contains information about the file and which pattern matched it. c^<V^8dQh/S[;R&S[S[,;R&S[S[,;R&#)rr*r/r3)rr r,r+)rrs"rrCheckResult.__annotate__xs3& 4.'2  3r rN)r*r/r3) rrrrr __slots____annotate_func__rrrs@rrrxs'   5r rc:a]tRtRtoRtRtV3RlRltRtVtR#)r9iz< The :class:`.MatchDetail` class contains information about c4<V^8dQhRS[S[,RR/#)rr)rN)rr)rrs"rrMatchDetail.__annotate__s hw/Dr c WnR#)z Initialize the :class:`.MatchDetail` instance. *patterns* (:class:`~collections.abc.Sequence` of :class:`~pathspec.pattern.Pattern`) contains the patterns that matched the file in the order they were encountered. Nr))rr)s&&rrMatchDetail.__init__s-r rN) rrrrrrrrrrs@rr9r9s r r9ca]tRtRtoRtRtV3RlRltRV3RlRlltRV3RlR lltV3R lR lt RV3R lR llt Rt Vt R#)rUizO The :class:`.TreeEntry` class contains information about a file-system entry. c ^<V^8dQhRS[RS[RS[PRS[PRR/#)rrnrlstatrorN)rr# stat_result)rrs"rrTreeEntry.__annotate__sE)) ) )  )  )  )r c <W0nWnW nW@nR#)a@ Initialize the :class:`.TreeEntry` instance. *name* (:class:`str`) is the base name of the entry. *path* (:class:`str`) is the relative path of the entry. *lstat* (:class:`os.stat_result`) is the stat result of the direct entry. *stat* (:class:`os.stat_result`) is the stat result of the entry, potentially linked. N_lstatrnr_stat)rrnrrros&&&&&rrTreeEntry.__init__s2*!&+ )) $*r Nc6<V^8dQhRS[S[,RS[/#rrTrr r,)rrs"rrrs)))$)r c VfRpV'd VPM VPp\P!VP4#)a0 Get whether the entry is a directory. *follow_links* (:class:`bool` or :data:`None`) is whether to follow symbolic links. If this is :data:`True`, a symlink to a directory will result in :data:`True`. Default is :data:`None` for :data:`True`. Returns whether the entry is a directory (:class:`bool`). T)rrroS_ISDIRst_moderrTrys&& rr"TreeEntry.is_dir5<(djjdkk) i'' ((r c6<V^8dQhRS[S[,RS[/#rr)rrs"rrrs))$)4)r c VfRpV'd VPM VPp\P!VP4#)a9 Get whether the entry is a regular file. *follow_links* (:class:`bool` or :data:`None`) is whether to follow symbolic links. If this is :data:`True`, a symlink to a regular file will result in :data:`True`. Default is :data:`None` for :data:`True`. Returns whether the entry is a regular file (:class:`bool`). T)rrroS_ISREGrrs&& rrqTreeEntry.is_filerr c <V^8dQhRS[/#r)r,)rrs"rrrs+++r c V\P!VPP4#)z? Returns whether the entry is a symbolic link (:class:`bool`). )roS_ISLNKrrrs&rrpTreeEntry.is_symlinks dkk)) **r cJ<V^8dQhRS[S[,RS[P/#r)r r,r#r)rrs"rrr s# 5 5htn 5 5r c NVfRpV'd VP#VP#)a- Get the cached stat result for the entry. *follow_links* (:class:`bool` or :data:`None`) is whether to follow symbolic links. If this is :data:`True`, the stat result of the linked file will be returned. Default is :data:`None` for :data:`True`. Returns that stat result (:class:`os.stat_result`). T)rr)rrTs&&rroTreeEntry.stat s$<#44r )rrrnrrN) rrrrrrrr"rqrprorrrs@rrUrUsI 1))V)) )) ++ 5 5 5r rU) r)NN)>rr#os.pathrrrosysrcollections.abcrr<rrN dataclassesrrtypingrrrr r r r r rrrrrr4r version_inforrVrr$altseprrr&r5rDrJrPr`r]r~rrr0rrrr Exceptionrrlrobjectr9rU)__seps0rrs    " v hsm# $ h  :W - vvryy!!U y}}$!  $8+\(P [FNb>L #(B%P"J.@,Y,^;Y;| $'(#>&2g5g5As/ F>FF