ˆhX SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r J r SSK Jr SSKJr SSKJrJrJrJ r JrJrJ r JrJrJrJrJrJrJrJr SSKJr \R@S :a \\!\\!4r"O\\!\4r"\"S \"S 9r#\RH\RJ4Vs/sH nU(dM U\RH:wdMUPM" snr&0r'S \RPS \!4Sjr)S\ \\*\4S\!S \\\+\\*44Sjr,S8S\ \S\ \!S\\+S \\!S44Sjjr-S\ \S \\\*\44Sjr.S\S \+4Sjr/S9S\"S\\\0/S4S\\+S \S4Sjjr1S\!S\!S \\!\!4S\\0/S4S\+S \S4 S!jr2S9S\"S\\\0/S4S\\+S \\!4S"jjr3S9S#jr4S$\!S \\/\44S%jr5S\ \S\!S \+4S&jr6S\ \S\ \!S \\!4S'jr7S8S\"S(\\ \!S \!4S)jjr8S8S\ \"S(\\ \!S \\!\\"44S*jjr9S8S$\!S+\\/\4S,\\+S S4S-jjr:"S.S/\;5r<"S0S1\;5r=\"S2S39"S4S5\\#55r>"S6S\?5r@"S7S\?5rAgs snf):zC This module provides utility methods for dealing with path-specs. N) CollectionIterable) dataclass)PathLike)AnyAnyStrCallablerDictGenericrIteratorListOptionalSequenceSetTupleTypeVarUnion)Pattern) TStrPath)boundpathreturncl[U5nUR5(aU[R- nU$)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`). )stris_dirossep)rstr_paths E/opt/services/DDDS/venv/lib/python3.13/site-packages/pathspec/util.pyappend_dir_sepr#Ds+ IKKMM bff(patternsfilecSnSnUH6upEURcMURU5cM(URnUnM8 X#4$)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 r"check_match_filer/VsM$ $ ^U __ W%7%7%=%I;9 r$files all_matches MatchDetailc[U[5(aUO [U5n0nUHnURcMUR U5nUR(aWUHOnXt;a9U(aXGR R U5 M.XTUR S'MA[U/5XG'MQ MUHnXH M M U$)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`). r) isinstanceCollectionTypelistr)matchr%appendr2) r%r0r1 all_files return_filesr. result_files result_filer&s r"detailed_match_filesr=rs,!77UT%[W __ -- *< oo# #  ))009/6K ))!,"-wi"8l$  !& r$cn[U5VVs/sHupURcMX4PM snn$s snnf)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_patternsrBs<"(+ +ng ]]7+  s11valuecf[U[5=(a [U[[45(+$)z Check whether the value is an iterable (excludes strings). *value* is the value to check, Returns whether *value* is a iterable (:class:`bool`). )r4 IterableTyperbytes)rCs r" _is_iterablerGs$ 5,'O 53,0O,OOr$rooton_error follow_links TreeEntryc## Ub [U5(d[SU<S35eUcSn[[RR U5S0X5ShvN gN7f)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_nextrrabspathrHrIrJs r"iter_tree_entriesrTsX4 (!3!3Ih\):;<<, #BGGOOD$92r8 ZZZsAA!AA! root_fulldir_relmemoc ## [RRX5n[RRU5nXb;aXU'O [ XbUUS9e[R "U5nUHn[RRXR 5n URSS9n UR5(aUR5n OU n URUS9(a0[UR XU 5v [X X#U5ShvN MUR5(dUR5(dM[UR XU 5v M SSS5 X& g![an UbU"U 5 Sn A GMSn A ff=f![an UbU"U 5 Sn A GM=Sn A ff=fN!,(df  N[=f7f)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)rrjoinrealpathRecursionErrorscandirnamestatOSError is_symlinkrrKrQis_file) rUrVrWrIrJdir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats r"rQrQs}6 GGLL , GG  X &  x.8nRYZZjjihggll7MM28 u5J Y Ioolo3 HMM8 CC&yDLYYYh1133 HMM8 CC?P ^A   a[   qk Z;sA,G ./F8E.-F8FAF8F6.F8F8# G . F8 F F8 FF8 F3 F.'F8.F33F88 GG c#z# [XUS9H)nURU5(aMURv M+ g7f)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*. rIrJN)rTrr)rHrIrJentrys r"iter_tree_filesrq3s24 lSU l # # Ts";;cJ[R"S[SS9 [XUS9$)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. stacklevelro)warningswarnDeprecationWarningrqrSs r" iter_treeryRs'  G1& lKKr$rac[U$)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)ras r"lookup_patternr|]s T""r$czSnUH2nURcMURU5cM&URnM4 U$)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&matchedr.s r"r*r*is= W __ W%7%7%=%I __7 r$c [R"[S[S3[SS9 UVs/sHo"RcMUPM nn[ 5nUH&n[ X55(dMURU5 M( U$s snf)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.rsrt)rvrw__name__rxr)setr*add)r%r0rA use_patternsr:r&s r" match_filesr}s}$  J0 ; 1& %-JH5 HJ T ##D Ks BB separatorscUc[n[R"U5nUH#nURU[R 5nM% UR S5(aUSSnU$UR S5(aUSSnU$)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`). N/rz./rs)NORMALIZE_PATH_SEPSrfspathreplace posixpathr startswith)r&r norm_filer s r"normalize_filers("*))D/ SY]]3) m)  4  m)r$c[R"S[SS9 0nUH+n[X1S9nXB;aX$R U5 M&U/X$'M- U$)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.rsrt)r)rvrwrxrr8)r0r norm_filesrrs r"normalize_filesrs^* $1&  TT9) % 6:  r$pattern_factoryoverridec[U[5(d[SU<S35e[U5(d[SU<S35eU[;aU(d[ U[U5eU[U'g)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:rMN)r4rrPrOr{AlreadyRegisteredError)rarrs r"register_patternrsq( 4E$!2344!!$_$77HIJJ  t%9$%?@@-dr$c^\rSrSrSrS\S\\/\4SS4U4Sjjr \ S\4Sj5r \ S\4S j5r \ S\\/\44S j5r S rU=r$) ri zy The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory is registered under a name already in use. rarrNc,>[[U] X5 g)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__)selfrar __class__s r"rAlreadyRegisteredError.__init__s.tEr$cJSRURURS9$)0 *message* (:class:`str`) is the error message. zG{name!r} is already registered for pattern factory:{pattern_factory!r}.)rar)formatrarrs r"messageAlreadyRegisteredError.message s. S Y Y '' Z r$c URS$)z> *name* (:class:`str`) is the name of the registered pattern. rargsrs r"raAlreadyRegisteredError.name*s 1r$c URS$)z[ *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrrs r"r&AlreadyRegisteredError.pattern_factory1 1r$)r __module__ __qualname____firstlineno____doc__rr rrrpropertyrrar__static_attributes__ __classcell__rs@r"rr s F  FVHg-. F F c  3   hx'89 r$rc^\rSrSrSrS\S\S\SS4U4Sjjr\S\4S j5r\S\4S j5r \S\4S j5r \S\4S j5r S r U=r $)r_i:zK The :exc:`RecursionError` exception is raised when recursion is detected. rYrZr[rNc.>[[U] XU5 g)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)rr_r)rrYrZr[rs r"rRecursionError.__init__@s$&ykJr$c URS$)zr *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrs r"rZRecursionError.first_pathTrr$c`SRURURURS9$)rzDReal path {real!r} was encountered at {first!r} and then {second!r}.)realfirstsecond)rrYrZr[rs r"rRecursionError.message\s5 P V V      W r$c URS$)zP *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs r"rYRecursionError.real_pathgrr$c URS$)zt *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rsrrs r"r[RecursionError.second_pathorr$r)rrrrrrrrrZrrYr[rrrs@r"r_r_:s K KK K  K(   c    # r$r_T)frozencL\rSrSr%SrSr\\S'\\ \S'\\ \S'Sr g) CheckResultixzb The :class:`CheckResult` class contains information about the file and which pattern matched it. )r&r)r-r&r)r-rN) rrrrr __slots__r__annotations__rboolintrrr$r"rrxs<   4.  r$rc4\rSrSrSrSrS\\SS4SjrSr g)r2iz< The :class:`.MatchDetail` class contains information about r%r%rNcXlg)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 r"rMatchDetail.__init__s-r$) rrrrrrrrrrrr$r"r2r2s& hw/Dr$c \rSrSrSrSrS\S\S\RS\RSS 4 S jr SS \ \ S\ 4S jjr SS \ \ S\ 4S jjr S\ 4SjrSS \ \ S\R4SjjrSrg )rKizO The :class:`.TreeEntry` class contains information about a file-system entry. _lstatrar_statrarlstatrbrNc:X0lXlX lX@lg)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. Nr)rrarrrbs r"rTreeEntry.__init__s2*!&+ )) $*r$rJcUcSnU(a URO URn[R"UR5$)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)rrrbS_ISDIRst_moderrJrms r"rTreeEntry.is_dir5<(djjdkk) i'' ((r$cUcSnU(a URO URn[R"UR5$)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)rrrbS_ISREGrrs r"reTreeEntry.is_filerr$cV[R"URR5$)z? Returns whether the entry is a symbolic link (:class:`bool`). )rbS_ISLNKrrrs r"rdTreeEntry.is_symlinks dkk)) **r$cJUcSnU(a UR$UR$)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)rrJs r"rbTreeEntry.stat s$<#44r$)rrrarN)rrrrrrrr stat_resultrrrrrerdrbrrr$r"rKrKs 1) ) )  )  )  )V))$) )$)4) ++ 5htn 5 5 5r$r)NN)Brros.pathpathlibrrbsysrvcollections.abcrr5rrE dataclassesrrtypingrrr r r r r rrrrrrr.r version_inforStrPathrr altseprr{Pathr#rrr/r=rBrGrcrTrQrqryr|r*rrrr Exceptionrr_robjectr2rK)__seps0r"rs1    " v hsm# $ h  :W - vvryy!!U y}}$!  #$ E#w,' (  8D>8C= ()> $+ G + +tn+ #}  +\ G  %W (PPP26 $ [ [ HgY_- . [~ [k [FN N N CH~N WItO $ N  N k Nf26 $ HgY_- .~c] >L # #6(G*;!< #'*#$( G   XF*.%% jo &% %T*."" jo &" #tG} "P!. .F8W,-. D>. .@,Y,^;Y;| $'(#>&2g5g5As I.II