jc(UdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z ddl mZddlmZmZmZmZmZmZmZddlmZdd lmZmZeeejefZed e Z ed ed Z ede Z! dej"ej#fDZ$ iZ%de&d< dZdZ' d[d\dZ( d[d]d$Z)d^d&Z*d_d*Z+ed+d`d,Z, d`dad3Z-dbd8Z. d`dcd:Z/ddd;Z0ded>Z1dfd?Z2ed@dgdBZ3 d[dhdEZ4edF d[didIZ5 d[djdNZ6GdOdPe7Z8GdQdRe7Z9ed SGdTdUee!Z:GdVdWe;Z<GdXdYe;Z=dS)kzC This module provides utility methods for dealing with path-specs. ) annotationsN) CollectionIterableIteratorSequence) dataclass)AnyCallableGenericOptionalTypeVarUnioncast)Pattern)AnyStr deprecatedTPattern)bound TPattern_coT)r covariantTStrPathc\g|])}|r%|tjktt|*S) posixpathseprstr).0__seps W/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/pathspec/util.py r!4sC  y}$$c5$$$z1dict[str, Callable[[Union[str, bytes]], Pattern]]_registered_patternspath pathlib.Pathreturnrcjt|}|r|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`). )ris_dirosr)r$str_paths r append_dir_sepr+Gs0 IIKKMM bf(r"patternsIterable[tuple[int, Pattern]]file is_reversedOptional[bool]$tuple[Optional[bool], Optional[int]]c|r1|D],\}}|j || |j|fcS-dSd}d}|D]*\}}|j|| |j}|}+||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)r,r.r/indexpattern out_include out_indexs r check_match_filer;Xs. !""neW o!g&8&8&>&>&J ?E !!!! !%+!) neW o!g&8&8&>&>&J/KI i r"Iterable[Pattern]files Iterable[str] all_matchesdict[str, MatchDetail]cXt|tr|nt|}i}|D]~}|ju||}|jrQ|D]M}||vr4|r!||j|)|||jd<:t|g||<Nv|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`). Nr) isinstancerlistr5matchr,append MatchDetail) r,r=r? all_files return_filesr8 result_files result_filer.s r detailed_match_filesrKs,! 33 DUUe(*W _ -- **< o#99 |## 7K )009999/6|K )!,,"-wi"8"8l;9 d  r"list[tuple[int, Pattern]]c4dt|DS)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`). c*g|]\}}|j ||fSNr5)r__index__pats r r!z*_filter_check_patterns..s3   gu ] Er") enumerater,s r _filter_check_patternsrUs+  !(++   r"valuer boolcft|tot|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`). )rBrrbytes)rVs r _is_iterablerZs* 5(##KJusEl,K,K(KKr"zGpathspec.util.iter_tree() is deprecated. Use iter_tree_files() instead.c&t|||S)z` .. version-deprecated:: 0.10.0 This is an alias for the :func:`.iter_tree_files` function. )on_error follow_links)iter_tree_filesrootr\r]s r iter_treeras xlKKKKr"r`StrPathr\#Optional[Callable[[OSError], None]]r]Iterator['TreeEntry']c#K|"t|std|d|d}ttj|di||Ed{VdS)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_nextr)r$abspathr_s r iter_tree_entriesrms|0 (!3!3;h;;;<<<, #BGOOD$9$92r8\ Z ZZZZZZZZZZr" root_fulldir_relmemodict[str, str]c #Ktj||}tj|}||vr|||<nt ||||tj|5}|D]>}tj||j} |d} n$#t$r} | || Yd} ~ \d} ~ wwxYw| r: |} n&#t$r} | || Yd} ~ d} ~ wwxYw| } | |r3t|j| | | Vt|| |||Ed{V| s| rt|j| | | V@ dddn #1swxYwY||=dS)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)r)r$joinrealpathRecursionErrorscandirnamestatOSError is_symlinkr( TreeEntryrkis_file) rnrorpr\r]dir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats r rkrks}4 GLLG , , G  X & & D$x..d8nRYZZZZj!DiDDhgll7HM228 u55JJ     Xa[[[ HHHH  YY hqkkk XXXX Ioolo33 D HM8Z C CCCC&y(D(LYYYYYYYYYYDh1133D HM8Z C CCCC?D!D!D!D!D!D!D!D!D!D!D!D!D!D!D!DP (^^^sg8+G$B;:G; C CGCG4D G D* D% G%D**BGG G  Iterator[str]c#K|"t|std|d|d}ttj|di||Ed{VdS)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*. NrfrgTrh)rirj_iter_tree_files_nextr)r$rlr_s r r^r^Ms|2 (!3!3;h;;;<<<, !"'//$"7"7R< X XXXXXXXXXXr"c #FKtj||}tj|}||vr|||<nt ||||tj|5}|D]}tj||j} ||rt|| |||Ed{VW| r| Vp|s| r| V dddn #1swxYwY||=dS)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`). rsrwN) r)r$ryrzr{r|r}r(rrr) rnrorpr\r]rrrrrs r rros4 GLLG , , G  X & & D$x..d8nRYZZZZjihgll7HM228oolo33 %Y$,WWWWWWWWWW NNNN X0022 NNN. (^^^s8BDDDr}Callable[[AnyStr], Pattern]ct|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#)r}s r lookup_patternrs T""r"cZd}|D]%}|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`. Fr4)r,r.matchedr8s r r6r6s@ W _ W%7%7%=%=%I _7r"z[pathspec.util.match_files() is deprecated. Use match_file() with a loop for better results.set[str]cd|D}t}|D]'}t||r||(|S)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`). c g|] }|j | SrOrP)rrRs r r!zmatch_files..sJJJ5 0I0I0I0Ir")setr6add)r,r= use_patternsrHr.s r match_filesrs].KJHJJJ T d##Dr" separatorsOptional[Collection[str]]c |t}| J|tj|}|D]"}||tj}#|dr |dd}n|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_SEPSr)fspathreplacerr startswith)r.r norm_filers r normalize_filers("* )D// 44SY]33)) m))4  m)r"zcpathspec.util.normalize_files() is deprecated. Use normalize_file() with a loop for better results.Iterable[StrPath]dict[str, list[StrPath]]ci}|D]9}t||}||vr|||3|g||<:|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)rrE)r=r norm_filesr$rs r normalize_filesrsf4)+ ""TTj999)* i%%%% 6:ir"pattern_factory`. rrrs r ruzRecursionError.first_pathrr"c8d|jd|jd|jdS)rz Real path z was encountered at z and then rrsrs r rzRecursionError.messages= %%%do%%%%%r"c|jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs r rtzRecursionError.real_pathrr"c|jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rrrs r rvzRecursionError.second_pathrr")rtrrurrvrr&rr) rrrrrrrurrtrvrrs@r r{r{s777777$  (  (  (  (r"r{)frozenc:eZdZUdZdZded< ded< ded<d S) CheckResultze The :class:`CheckResult` class contains information about the file and which pattern matched it. )r.r5r7rr.r0r5z Optional[int]r7N)rrrr __slots____annotations__rr"r rrsX   r"rceZdZdZdZd dZdS) rFz> The :class:`.MatchDetail` class contains information about rTr,Sequence[Pattern]r&rc||_dS)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. NrT)rr,s r rzMatchDetail.__init__s$-r"N)r,rr&r)rrrrrrrr"r rFrFs9       r"rFcDeZdZdZdZdd ZdddZdddZddZdddZ d S)rzP The :class:`TreeEntry` class contains information about a file-system entry. _lstatr}r$_statr}rr$lstatos.stat_resultr~r&rcD||_ ||_ ||_ ||_dS)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)rr}r$rr~s r rzTreeEntry.__init__s?(!&$+$)$) $$*r"Nr]r0rWc\|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`). NT)rrr~S_ISDIRst_moderr]rs r r(zTreeEntry.is_dir-4<(9djjdk) 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`). NT)rrr~S_ISREGrrs r rzTreeEntry.is_file=rr"c>tj|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )r~S_ISLNKrrrs r rzTreeEntry.is_symlinkMs dk) * **r"c*|d}|r|jn|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`). NT)rr)rr]s r r~zTreeEntry.statSs"<# 44r") r}rr$rrrr~rr&rrO)r]r0r&rW)r&rW)r]r0r&r) rrrrrrr(rrr~rr"r rrs 1&&&&P))))) ))))) ++++ 5 5 5 5 5 5 5r"r)r$r%r&rrO)r,r-r.rr/r0r&r1)r,r<r=r>r?r0r&r@)r,r<r&rL)rVr r&rWr3)r`rbr\rcr]r0r&rd) rnrrorrprqr\rcr]rWr&rd)r`rbr\rcr]r0r&r) rnrrorrprqr\rcr]rWr&r)r}rr&r)r,r<r.rr&rW)r,r<r=r>r&r)r.rbrrr&r)r=rrrr&r)r}rrrrr0r&r)>r __future__rr)os.pathpathlibrr~collections.abcrrrr dataclassesrtypingr r r r r rrr8r_typingrrrPathLikerbrrrraltseprr#rr+r;rKrUrZrarmrkr^rrr6rrrr Exceptionrr{robjectrFrrr"r rs#"""""                                   R[%% & 7:W - - - gm7dCCC  7:W - - -vry! KMLLLL ( $) ) ) ) ) ^ $,,,,,^(LLLL JLLLL26 $[[[[[BLLLLb26 $YYYYYD;;;;| # # # #(  >*.'''''T  *. H!.....>,,,,,Y,,,^77777Y777t $'(#>&0c5c5c5c5c5c5c5c5c5c5r"