AeN dZddlZddlZddlZddlZddlZddlZddlmZ m Z ddlm Z ddl mZmZmZmZmZm Z mZmZmZmZmZmZddlmZej4ej6fDcgc]}|r|ej4k7r|c}Z iZ dej<d efd Z d/d e ed e ed ee!d eedffdZ"d e ed eefdZ#ded e!fdZ$ d0deee fdeedee!d edfdZ%dededeeefdede!d edf dZ& d0deee fdeedee!d eefdZ'd0dZ(ded eegeffdZ)d e ed ed e!fd!Z*d e ed e ed eefd"Z+ d/d eee fd#eeed efd$Z, d/d e eee fd#eeed eeeeee fffd%Z- d/ded&eegefd'ee!d dfd(Z.Gd)d*e/Z0Gd+d,e/Z1Gd-de2Z3Gd.de2Z4ycc}w)1zC This module provides utility methods for dealing with path-specs. N) CollectionIterable)PathLike) AnyAnyStrCallablerDictrIteratorListOptionalSequenceSetUnion)Patternpathreturncbt|}|jr|tjz }|S)a5 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 -lib/python3.12/site-packages/pathspec/util.pyappend_dir_sepr4s) IKKM bff(patternsfiles all_matches MatchDetailcXt|tr|n t|}i}|D]}|j|j |}|jrO|D]I}||vr4|r||j j |(|||j d<;t|g||<K||D]}||=|S)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:`boot` 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) isinstanceCollectionTypelistincludematchrappendr ) rrr all_files return_filespattern result_files result_filefiles rdetailed_match_filesr.Fs,!7UT%[W __ -- *< oo#9 |# K ))009/6|K ))!,"-wi"8l;9 d !& rcD|Dcgc]}|j|c}Scc}w)z Filters out null-patterns. *patterns* (:class:`Iterable` of :class:`.Pattern`) contains the patterns. Returns the patterns (:class:`list` of :class:`.Pattern`). )r%)r__pats r_filter_patternsr1ts.   ]]  svaluecTt|txrt|ttf S)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)r2s r _is_iterabler6s$ 5,'O 53,0O,OOrrooton_error follow_links TreeEntryc#K|t|std|d|d}ttjj |di||Ed{y7w)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_nextrrabspathr7r8r9s riter_tree_entriesrCsX4 (!3Ih\):;<<, #BGGOOD$92r8\ ZZZsAAAA root_fulldir_relmemoc #xKtjj||}tjj|}||vr|||<nt ||||tj |5}|D]}tjj||j } |jd} |jr |j} n| } |j|r2t|j | | | t|| |||Ed{|js|jst|j | | |  ddd||=y#t$r} ||| Yd} ~  d} ~ wwxYw#t$r} ||| Yd} ~ ,d} ~ wwxYw7#1swY||=yxYww)aq 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_symlinkrr:r@is_file) rDrErFr8r9dir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats rr@r@s6 GGLLG , GG  X &  D$x.d8nRYZZjj!DiDhggll7HMM28 u5J Y Ioolo3 HMM8Z CC&y(D(LYYYh113 HMM8Z CC?D!DP (^A   a[   qk Z;!DP (^sA0F:20F+#E'5F+FAF+F)%F+>F+ F:' F0 F:F+FF+ F& F!F+!F&&F++F70 F:c#rKt|||D]"}|j|r|j$yw)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*. r8r9N)rCrr)r7r8r9entrys riter_tree_filesr`s64 xlSU l # s#77cVtjdtdt|||S)zg 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`rBs r iter_treerh"s)  G1& xlKKrrPct|S)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)rPs rlookup_patternrk-s T""rr-cnd}|D]-}|j|j|"|j}/|S)a7 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`. F)r% match_file)rr-matchedr*s rrmrm9sC W __  *ooG rctjdtdt|}t }|D] }t ||s|j |"|S)a DEPRECATED: This is an old function no longer used. Use the :func:`.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`). zWutil.match_files() is deprecated. Use util.match_file() with a loop for better results.rbrc)rerfrgr1setrmadd)rr use_patternsr)r-s r match_filesrsNs\$ 1& !* T d#D r separatorsc|t}t|}|D]"}|j|tj}$|j dr|dd}|S|j dr|dd}|S)a Normalizes the file path to use the POSIX path separator (i.e., :data:`'/'`), and make the paths relative (remove leading :data:`'/'`). *file* (:class:`str` or :class:`os.PathLike`) is the file path. *separators* (:class:`~collections.abc.Collection` of :class:`str`; or :data:`None`) optionally contains the path separators to normalize. This does not need to include the POSIX path separator (:data:`'/'`), but including it will not affect the results. Default is :data:`None` for :data:`NORMALIZE_PATH_SEPS`. To prevent normalization, pass an empty container (e.g., an empty tuple :data:`()`). Returns the normalized file path (:class:`str`). N/rz./rb)NORMALIZE_PATH_SEPSrreplace posixpathr startswith)r-rt norm_filers rnormalize_filer|os("*Y 4SY]]3)4m)  4 m)rctjdtdi}|D].}t||}||vr||j |)|g||<0|S)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.rbrc)rt)rerfrgr|r')rrt norm_filesrr{s rnormalize_filesrsk* $1&  "TTj9)* i% 6:i " rpattern_factoryoverridect|tstd|dt|std|d|tvr|st |t||t|<y)aE 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:r<N)r"rr?r>rjAlreadyRegisteredError)rPrrs rregister_patternrsk( 4E$!2344!$_$77HIJJ  t%9$%?@@-drceZdZdZdedeegefddffd Ze defdZ e defdZ e deegeffd Z xZ S) rz| The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory is registered under a name already in use. rPrrNc.tt| ||y)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__)selfrPr __class__s rrzAlreadyRegisteredError.__init__s.t_ErcPdj|j|jS)4 *message* (:class:`str`) is the error message. zG{name!r} is already registered for pattern factory:{pattern_factory!r}.)rPr)formatrPrrs rmessagezAlreadyRegisteredError.messages. S Y Y '' Z rc |jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrs rrPzAlreadyRegisteredError.names 1rc |jdS)za *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrrs rrz&AlreadyRegisteredError.pattern_factory 1r)__name__ __module__ __qualname____doc__rrrrrpropertyrrPr __classcell__rs@rrrs F  FVHg-. F F c  3   hx'89 rrceZdZdZdedededdffd ZedefdZedefd Zedefd Z edefd Z xZ S) rNzN The :exc:`RecursionError` exception is raised when recursion is detected. rHrIrJrNc0tt| |||y)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)rrNr)rrHrIrJrs rrzRecursionError.__init__s$&y*kJrc |jdS)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrs rrIzRecursionError.first_path%rrcfdj|j|j|jS)rzDReal path {real!r} was encountered at {first!r} and then {second!r}.)realfirstsecond)rrHrIrJrs rrzRecursionError.message-s5 P V V      W rc |jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs rrHzRecursionError.real_path8rrc |jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rbrrs rrJzRecursionError.second_path@rr) rrrrrrrrIrrHrJrrs@rrNrN s K KK K  K(   c    # rrNc*eZdZdZdZdeeddfdZy)r z> The :class:`.MatchDetail` class contains information about rrrNc||_y)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)rrs rrzMatchDetail.__init__Qs$-r)rrrr __slots__r rrrrr r Is& hw/Drc eZdZdZdZdededejdejddf d Zdd e e de fd Z dd e e de fd Z de fd Z dd e e dejfdZy)r:zR The :class:`.TreeEntry` class contains information about a file-system entry. _lstatrPr_statrPrlstatrQrNcB||_ ||_ ||_ ||_y)aP 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)rrPrrrQs rrzTreeEntry.__init__ks:*!&$+ $)$) $$*rr9c||d}|r |jn |j}tj|jS)a< 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)rrrQS_ISDIRst_moderr9r\s rrzTreeEntry.is_dir5<(djjdkk) i'' ((rc||d}|r |jn |j}tj|jS)aE 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)rrrQS_ISREGrrs rrTzTreeEntry.is_filerrcTtj|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )rQS_ISLNKrrrs rrSzTreeEntry.is_symlinks dkk)) **rc>|d}|r |jS|jS)a9 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)rr9s rrQzTreeEntry.stats$<#44rN)rrrrrrr stat_resultrr boolrrTrSrQrrrr:r:bs 1) ) )  )  )  )V))$) )$)4) ++ 5htn 5 5rr)NN)5rros.pathpathlibryrQrecollections.abcrr#rr4rtypingrrrr r r r r rrr*rraltseprwrjPathrrrr.r1r6rCr@r`rhrkrmrsr|rr ExceptionrrNobjectr r:)__seps0rrst        vvryy!  ey}}$  #* $+ G + +tn+ #}  +\ x0 T']  PPP!% $ [ S(] [ H  [~ [k [FN N N CH~N  N  N k Nf!% $ S(] H ~c] >L # #6(G*;!< #'*#$* G   XF*.% S(]% jo &% %T*."sH}%&" jo &" #tE#x-() )*"P!. .F8W,-. D>. .@,Y,^;Y;|&2g5g5Cs%G