0yi` dZddlZddlZddlZddlZddlZddlmZmZm Z m Z ddl m Z ddl mZmZmZmZmZmZddlmZddlmZmZeeej4efZed e Z ej:ej<fDcgc]}|r|ej:k7r|c}Z iZ d ejBd efd Z" dGd;de=Z?ycc}w)>zC This module provides utility methods for dealing with path-specs. N) CollectionIterableIteratorSequence) dataclass)AnyCallableGenericOptionalTypeVarUnion)Pattern)AnyStr deprecatedTStrPath)boundpathreturncbt|}|jr|tjz }|S)a4 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 O/var/www/html/content_weaver/venv/lib/python3.12/site-packages/pathspec/util.pyappend_dir_sepr9s) IKKM bff(patternsfile is_reversedc|r9|D]3\}}|j|j|%|j|fcSyd}d}|D]2\}}|j|j|%|j}|}4||fS)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 actua pattern (:class:`.Pattern`). *file* (:class:`str`) is the normalized file path to be matched against *patterns*. *is_reversed* (:class:`bool` or :data:`None`) is whether the order of the patterns has been reversed. Default is :data:`None` for :data:`False`. Reversing the order of the patterns is an optimization. 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`). NNNinclude match_file)rr r!indexpattern out_include out_indexs rcheck_match_filer+Js.!"neW oo!g&8&8&>&J ??E !!" !%+!) neW oo!g&8&8&>&J//KI i rfiles 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:`.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) isinstancerlistr%matchrappendr.) rr,r- all_files return_filesr( result_files result_filer s rdetailed_match_filesr8vs,! 3UeW __ -- *< oo#9 |# K ))009/6|K ))!,"-wi"8l;9 d !& rcft|Dcgc]\}}|j||fc}}Scc}}w)a& Filters out null-patterns. *patterns* (:class:`~collections.abc.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:`.Pattern`). ) enumerater%)r__index__pats r_filter_check_patternsr=s<"(+ gu ]] E  s-valuecTt|txrt|ttf S)z Check whether the value is an iterable (excludes strings). *value* is the value to check, Returns whether *value* is an iterable (:class:`bool`). )r0rrbytes)r>s r _is_iterablerAs$ 5(#KJusEl,K(KKrzGpathspec.util.iter_tree() is deprecated. Use iter_tree_files() instead.ct|||S)z` .. version-deprecated:: 0.10.0 This is an alias for the :func:`.iter_tree_files` function. )on_error follow_links)iter_tree_filesrootrCrDs r iter_treerHs xlKKrrGrCrD 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*. N on_error: is not callable.T)callable TypeError_iter_tree_entries_nextrrabspathrFs riter_tree_entriesrRsX0 (!3Ih\):;<<, #BGGOOD$92r8\ ZZZAAAA 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)ap 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_pathFfollow_symlinksN)rrjoinrealpathRecursionErrorscandirnamestatOSError is_symlinkrrIrPis_file) rTrUrVrCrDdir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats rrPrPs4 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#K|t|std|d|d}ttjj |di||Ed{y7w)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*. NrKrLTrM)rNrO_iter_tree_files_nextrrrQrFs rrErE>sX2 (!3Ih\):;<<, !"''//$"7R< XXXrSc #6Ktjj||}tjj|}||vr|||<nt ||||tj |5}|D]}tjj||j } |j|rt|| |||Ed{W|jr| l|ro|js|  ddd||=y7A#1swY||=yxYww)am 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 file path (:class:`str`). rXr\N) rrr^r_r`rarbrrprfre) rTrUrVrCrDrgrhrirjrks rrprp`s4 GGLLG , GG  X & D$x.d8nRYZZjjihggll7HMM28oolo3%Y$,WWW N X002 N. (^X. (^s=A0D2AD DD $D 5D < DD  D Drbct|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)rbs rlookup_patternrts T""rcnd}|D]-}|j|j|"|j}/|S)a& Matches the file to the patterns. *patterns* (:class:`~collections.abc.Iterable` of :class:`.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$)rr matchedr(s rr&r&sB W __ W%7%7%=%I __7 rz[pathspec.util.match_files() is deprecated. Use match_file() with a loop for better results.c|Dcgc]}|j|}}t}|D] }t||s|j|"|Scc}w)a .. version-deprecated:: 0.10.0 This function is 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:`.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`). )r%setr&add)rr,r< use_patternsr5r s r match_filesr{s\.%-J5 0IJJ T d#D Ks AA separatorsc|t}tj|}|D]"}|j|tj }$|j dr|dd}|S|j dr|dd}|S)a 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 :data:`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 :data:`.NORMALIZE_PATH_SEPS`. To prevent normalization, pass an empty container (e.g., an empty tuple ``()``). Returns the normalized file path (:class:`str`). N/rz./)NORMALIZE_PATH_SEPSrfspathreplace posixpathr startswith)r r| norm_filers rnormalize_filers("*))D/ 4SY]]3)4m)  4 m)rzcpathspec.util.normalize_files() is deprecated. Use normalize_file() with a loop for better results.cpi}|D].}t||}||vr||j|)|g||<0|S)a .. version-deprecated:: 0.10.0 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`). )r|)rr3)r,r| norm_filesrrs rnormalize_filesrsS4 "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:rLN)r0rrOrNrsAlreadyRegisteredError)rbrrs rregister_patternr,sk& 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. rbrrNc&t|||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. Nsuper__init__)selfrbr __class__s rrzAlreadyRegisteredError.__init__Qs'4)rc:|jd|jdS)4 *message* (:class:`str`) is the error message. z+ is already registered for pattern factory=.)rbrrs rmessagezAlreadyRegisteredError.message`s(  ii]= Q rc |jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrs rrbzAlreadyRegisteredError.namejs 1rc |jdS)za *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrrs rrz&AlreadyRegisteredError.pattern_factoryq 1r)__name__ __module__ __qualname____doc__rr rrrpropertyrrbr __classcell__rs@rrrKs *  *VHg-. * * c  3   hx'89 rrceZdZdZdedededdffd ZedefdZedefd Zedefd Z edefd Z xZ S) r`zM The :exc:`RecursionError` exception is raised when recursion is detected. rYrZr[rNc(t||||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*. Nr)rrYrZr[rs rrzRecursionError.__init__s '9j+6rc |jdS)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrs rrZzRecursionError.first_pathrrcVd|jd|jd|jdS)rz Real path z was encountered at z and then rrXrs rrzRecursionError.messages: !!5doo5HI"!%rc |jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs rrYzRecursionError.real_pathrrc |jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rrrs rr[zRecursionError.second_pathrr) rrrrrrrrZrrYr[rrs@rr`r`zs7 77 7  7$   c    # rr`T)frozencDeZdZUdZdZeed< eeed< ee ed<y) CheckResultze The :class:`CheckResult` class contains information about the file and which pattern matched it. )r r%r'r r%r'N) rrrr __slots__r__annotations__r boolintrrrrs<   4.  rrc*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:`.Pattern`) contains the patterns that matched the file in the order they were encountered. Nr)rrs rrzMatchDetail.__init__s$-r)rrrrrrrrrrrr.r.s&  hw/ D rc eZdZdZdZdededejdejddf d Zdd e e de fd Z dd e e de fd Z de fd Z dd e e dejfdZy)rIzP The :class:`TreeEntry` class contains information about a file-system entry. _lstatrbr_statrbrlstatrcrNcB||_ ||_ ||_ ||_y)aM 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)rrbrrrcs rrzTreeEntry.__init__s:(!&$+$)$) $$*rrDc||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)rrrcS_ISDIRst_moderrDrns 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)rrrcS_ISREGrrs rrfzTreeEntry.is_file,rrcTtj|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )rcS_ISLNKrrrs rrezTreeEntry.is_symlink<s 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)rrDs rrczTreeEntry.statBs$<#44rN)rrrrrrr stat_resultrr rrrfrercrrrrIrIs 1& & &  &  &  &P))$) )$)4) ++ 5htn 5 5rrr#)@rros.pathpathlibrrccollections.abcrrrr dataclassesrtypingrr r r r r r(r_typingrrrPathLikeStrPathrraltseprrsPathrtuplerrr+dictr8r1r=rArHrdrRrPrErprtr&rxr{rrr Exceptionrr`robjectr.rI)__seps0rrs        R[[%% & :W - vvryy!  ey}}$  #( $) E#w,' ()  ) tn)  8D>8C= () ) ^ $+ G + +tn+ #}  +\ G  %W (LLL JLL26 $[[ HgY_- .[~[k [BL L L CH~L WItO $ L  L k Lb26 $YY HgY_- .Y~Yc] YD; ; ; CH~; WItO $ ;  ; c] ;| # #6(G*;!< #'*#$(  G   X >*.%% jo &% %P  *. jo & #tG}  H!. .F8W,-. D>. .>,Y,^7Y7t $'(#>&0c5c5MsI&