hKjcUdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z ddl mZddlmZmZmZmZmZmZmZddlmZdd lmZmZeeej:efZed e Z ed ed Z ede Z! ejDejFfDcgc]}|r|ejDk7r ee|c}Z$ iZ%de&d< d0dZ' d1 d2dZ( d1 d3dZ) d4dZ*d5dZ+edd6dZ, d6 d7dZ- d8dZ. d6 d9dZ/ d:dZ0d;dZ1dd!Z4ed" d1 d?d#Z5 d1 d@d$Z6Gd%d&e7Z8Gd'd(e7Z9ed )Gd*d+ee!Z:Gd,d-e;Z<Gd.d/e;Z=ycc}w)AzC This module provides utility methods for dealing with path-specs. ) annotationsN) CollectionIterableIteratorSequence) dataclass)AnyCallableGenericOptionalTypeVarUnioncast)Pattern)AnyStr deprecatedTPattern)bound TPattern_coT)r covariantTStrPathz1dict[str, Callable[[Union[str, bytes]], Pattern]]_registered_patternscbt|}|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)pathstr_paths R/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/pathspec/util.pyappend_dir_sepr"Gs) IKKM bff(c|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)patternsfile is_reversedindexpattern out_include out_indexs r!check_match_filer0Xs.!"neW oo!g&8&8&>&J ??E !!" !%+!) neW oo!g&8&8&>&J//KI i r#cXt|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'matchr)append MatchDetail) r)files all_matches all_files return_filesr- result_files result_filer*s r!detailed_match_filesr=s,! 3Ue(*W __ -- *< oo#9 |# K ))009/6|K ))!,"-wi"8l;9 d #( r#cft|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_patternsrBs<"(+ gu ]] E  s-cTt|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`). )r2rrbytes)values r! _is_iterablerFs$ 5(#KJusEl,K(KKr#zGpathspec.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_filesrootrHrIs r! iter_treerMs xlKKr#c#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_nextrrabspathrKs r!iter_tree_entriesrVsX0 (!3Ih\):;<<, #BGGOOD$92r8\ ZZZAAAAc #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_symlinkr TreeEntryrTis_file) root_fulldir_relmemorHrIdir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats r!rTrTs4 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*. NrOrPTrQ)rRrS_iter_tree_files_nextrrrUrKs r!rJrJMsX2 (!3Ih\):;<<, !"''//$"7R< XXXrWc #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`). rYr]N) rrr_r`rarbrcrrurhrf) rirjrkrHrIrlrmrnrorps r!ruruos4 GGLLG , GG  X & D$x.d8nRYZZjjihggll7HMM28oolo3%Y$,WWW N X002 N. (^X. (^s=A0D2AD DD $D 5D < DD  D Dct|S)z Looks up 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`. )r)rcs r!lookup_patternrxs T""r#cnd}|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&)r)r*matchedr-s r!r(r(sB W __ W%7%7%=%I __7 r#z[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)r)r7rA use_patternsr:r*s r! match_filesrs\.%-J5 0IJJ T d#D Ks AAc|t}|J|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* separators norm_filers r!normalize_filers("** *))D/ 4SY]]3)4m)  4 m)r#zcpathspec.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)rr5)r7r norm_filesrrs r!normalize_filesrsS4)+ "TTj9)* i% 6:i " r#ct|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=rPN)r2rrSrRrAlreadyRegisteredError)rcpattern_factoryoverrides r!register_patternr=sk& 4UTI./00!%_((9:;;  t%9$%?@@-dr#cfeZdZdZ dfd ZeddZeddZeddZxZ S) rz| The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory is registered under a name already in use. c&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__)selfrcr __class__s r!rzAlreadyRegisteredError.__init__bs'4)r#c:|jd|jdS)4 *message* (:class:`str`) is the error message. z+ is already registered for pattern factory=.)rcrrs r!messagezAlreadyRegisteredError.messageqs(  ii]= Q r#c |jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrs r!rczAlreadyRegisteredError.name{s 1r#c |jdS)za *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrrs r!rz&AlreadyRegisteredError.pattern_factory 1r#)rcrr&Callable[[Union[str, bytes]], Pattern]returnNonerr)rr) __name__ __module__ __qualname____doc__rpropertyrrcr __classcell__rs@r!rr\se *  *: * *       r#rc|eZdZdZ dfd ZeddZeddZeddZeddZ xZ S) razM The :exc:`RecursionError` exception is raised when recursion is detected. c(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)rrZr[r\rs r!rzRecursionError.__init__s '9j+6r#c |jdS)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrs r!r[zRecursionError.first_pathrr#cVd|jd|jd|jdS)rz Real path z was encountered at z and then rrYrs r!rzRecursionError.messages: !!5doo5HI"!%r#c |jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs r!rZzRecursionError.real_pathrr#c |jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rrrs r!r\zRecursionError.second_pathrr#)rZrr[rr\rrrr) rrrrrrr[rrZr\rrs@r!raras7 77 7  7$        r#ra)frozenc8eZdZUdZdZded< ded< ded<y ) CheckResultze The :class:`CheckResult` class contains information about the file and which pattern matched it. )r*r'r,rr*Optional[bool]r'z Optional[int]r,N)rrrr __slots____annotations__r#r!rrs4    r#rceZdZdZdZddZy)r6z> The :class:`.MatchDetail` class contains information about r)c||_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)rr)s r!rzMatchDetail.__init__s$-r#N)r)zSequence[Pattern]rr)rrrrrrrr#r!r6r6s  r#r6cVeZdZdZdZ d dZd d dZd d dZd dZd d dZ y)rgzP The :class:`TreeEntry` class contains information about a file-system entry. _lstatrcr_statcB||_ ||_ ||_ ||_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)rrcrlstatrds r!rzTreeEntry.__init__s:(!&$+$)$) $$*r#Nc||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)rrrdS_ISDIRst_moderrIrss r!rzTreeEntry.is_dir-5<(djjdkk) i'' ((r#c||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)rrrdS_ISREGrrs r!rhzTreeEntry.is_file=rr#cTtj|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )rdS_ISLNKrrrs r!rfzTreeEntry.is_symlinkMs dkk)) **r#c>|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)rrIs r!rdzTreeEntry.statSs$<#44r#) rcrrrros.stat_resultrdrrrN)rIrrbool)rr)rIrrr) rrrrrrrrhrfrdrr#r!rgrgsX 1& & &  &  &  &P) ) + 5r#rg)rz pathlib.Pathrrr)r)zIterable[tuple[int, Pattern]]r*rr+rrz$tuple[Optional[bool], Optional[int]])r)Iterable[Pattern]r7 Iterable[str]r8rrzdict[str, MatchDetail])r)rrzlist[tuple[int, Pattern]])rEr rrr%)rLStrPathrH#Optional[Callable[[OSError], None]]rIrrIterator['TreeEntry']) rirrjrrkdict[str, str]rHrrIrrr)rLrrHrrIrr Iterator[str]) rirrjrrkrrHrrIrrr)rcrrzCallable[[AnyStr], Pattern])r)rr*rrr)r)rr7rrzset[str])r*rrOptional[Collection[str]]rr)r7zIterable[StrPath]rrrzdict[str, list[StrPath]])rcrrzr __future__rros.pathpathlibrrdcollections.abcrrrr dataclassesrtypingr r r r r rrr-r_typingrrrPathLikerrrrraltseprrrr"r0r=rBrFrMrVrTrJrurxr(rrrr Exceptionrrarobjectr6rg)__seps0r!rs#        R[[%% & :W - m7dC  :W - vvryy!  ey}}$c5 KMGL ( $) ()  ) ) * ) ^ $, ,,, ,^ (L JLL26 $[[ .[[ [BL L LL / L  L  Lb26 $YY .YY YD; ; ;; / ;  ;  ;| #(   >*.'' &' 'T  *. & H!. .N. . .>,Y,^7Y7t $'(#>&0c5c5Ss !G