mi` dZddlZddlZddlZddlZddlZddlmZmZm Z m Z ddl m Z ddl mZmZmZmZmZmZddlmZddlmZmZeeejefZed e Z d ejejfDZ iZ d ej!d efdZ" d=dee#e$efdedee%d e#ee%ee$ffdZ& d=deedeedee%d e'edffdZ(deed e)e#e$effdZ*ded e%fdZ+edd>dZ, d>dedeee-gdfdee%d e dfd Z.d!ed"ed#e'eefdee-gdfde%d e df d$Z/ d>dedeee-gdfdee%d e efd%Z0d!ed"ed#e'eefdee-gdfde%d e ef d&Z1d'ed eegeffd(Z2deeded e%fd)Z3ed*deedeed e4efd+Z5 d=ded,eeed efd-Z6ed. d=deed,eeed e'ee)effd/Z7 d=d'ed0eegefd1ee%d dfd2Z8Gd3d4e9Z:Gd5d6e9Z;e d78Gd9d:eeZ<Gd;de=Z>Gd<de=Z?dS)?zC This module provides utility methods for dealing with path-specs. N) CollectionIterableIteratorSequence) dataclass)AnyCallableGenericOptionalTypeVarUnion)Pattern)AnyStr deprecatedTStrPath)boundc6g|]}|r|tjk|S) posixpathsep).0__seps e/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/lib/python3.11/site-packages/pathspec/util.py r&s9  y}$$$$$pathreturncjt|}|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`). )stris_dirosr)rstr_paths rappend_dir_sepr$9s0 IIKKMM bf(rpatternsfile is_reversedc|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 rcheck_match_filer1Js. !""neW o!g&8&8&>&>&J ?E !!!! !%+!) neW o!g&8&8&>&>&J/KI i rfiles all_matches MatchDetailcXt|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) isinstancerlistr+matchr%appendr4) r%r2r3 all_files return_filesr. result_files result_filer&s rdetailed_match_filesr>vs,! 33 DUUeW _ -- **< o#99 |## 7K )009999/6|K )!,,"-wi"8"8l;9 d  rc4dt|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 ||fSNr+)r__index__pats rrz*_filter_check_patterns..s3   gu ] Er) enumerater%s r_filter_check_patternsrGs+  !(++   rvaluecft|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`). )r6rr bytes)rHs r _is_iterablerKs* 5(##KJusEl,K,K(KKrzGpathspec.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_filesrootrMrNs r iter_treerRs xlKKKKrrQrMrN TreeEntryc#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"rabspathrPs riter_tree_entriesr\s|0 (!3!3;h;;;<<<, #BGOOD$9$92r8\ Z ZZZZZZZZZZr root_fulldir_relmemoc #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"rjoinrealpathRecursionErrorscandirnamestatOSError is_symlinkr!rSrZis_file) r]r^r_rMrNdir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats rrZrZs}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 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*. NrUrVTrW)rXrY_iter_tree_files_nextr"rr[rPs rrOrO>s|2 (!3!3;h;;;<<<, !"'//$"7"7R< X XXXXXXXXXXrc #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`). rareN) r"rrgrhrirjrkr!ryrorn) r]r^r_rMrNrprqrrrsrts rryry`s4 GLLG , , G  X & & D$x..d8nRYZZZZjihgll7HM228oolo33 %Y$,WWWWWWWWWW NNNN X0022 NNN. (^^^s8BDDDrkct|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)rks rlookup_patternr}s T""rcZd}|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`. Fr*)r%r&matchedr.s rr,r,s@ W _ W%7%7%=%=%I _7rz[pathspec.util.match_files() is deprecated. Use match_file() with a loop for better results.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 | SrArB)rrDs rrzmatch_files..sJJJ5 0I0I0I0Ir)setr,add)r%r2 use_patternsr;r&s r match_filesrs].KJHJJJ T d##Dr separatorsc|t}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 rnormalize_filers("*)D// 44SY]33)) m))4  m)rzcpathspec.util.normalize_files() is deprecated. Use normalize_file() with a loop for better results.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)rr9)r2r norm_filesrrs rnormalize_filesrsf4 ""TTj999)* i%%%% 6:irpattern_factoryoverridect|tstd|dt|std|d|tvr|st |t||t|<dS)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:rVN)r6r rYrXr|AlreadyRegisteredError)rkrrs rregister_patternr,s& 453$333444!!KI_IIIJJJ    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. rkrrNcLt||dS)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__)selfrkr __class__s rrzAlreadyRegisteredError.__init__Qs%''4)))))rc&|jd|jdS)4 *message* (:class:`str`) is the error message. z+ is already registered for pattern factory=.)rkrrs rmessagezAlreadyRegisteredError.message`s-  i      rc|jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrs rrkzAlreadyRegisteredError.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__r r rrrpropertyrrkr __classcell__rs@rrrKs *  *VHg-. * * * * * * * c ( 3 (  hx'89 (rrceZdZdZdedededdffd ZedefdZedefd Zedefd Z edefd Z xZ S) rizM The :exc:`RecursionError` exception is raised when recursion is detected. rbrcrdrNcNt|||dS)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)rrbrcrdrs rrzRecursionError.__init__s' ''9j+66666rc|jdS)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrs rrczRecursionError.first_pathrrc8d|jd|jd|jdS)rz Real path z was encountered at z and then rrars rrzRecursionError.messages= %%%do%%%%%rc|jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs rrbzRecursionError.real_pathrrc|jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rrrs rrdzRecursionError.second_pathrr) rrrrr rrrcrrbrdrrs@rririzs 7 77 7  777777$  ( c (  ( # (rriT)frozencReZdZUdZdZeed< eeed< ee ed<dS) 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 boolintrrrrrs`   4.  rrc2eZdZdZdZdeeddfdZdS)r4z> The :class:`.MatchDetail` class contains information about rFr%rNc||_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. NrF)rr%s rrzMatchDetail.__init__s$-r)rrrrrrrrrrrr4r4sL  hw/ D      rc eZdZdZdZdededejdejddf d Zdd e e de fd Z dd e e de fd Z de fd Z dd e e dejfdZdS)rSzP The :class:`TreeEntry` class contains information about a file-system entry. _lstatrkr_statrkrlstatrlrNcD||_ ||_ ||_ ||_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)rrkrrrls rrzTreeEntry.__init__s?(!&$+$)$) $$*rrNc\|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)rrrlS_ISDIRst_moderrNrws rr!zTreeEntry.is_dir4<(9djjdk) 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`). NT)rrrlS_ISREGrrs rrozTreeEntry.is_file,rrc>tj|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )rlS_ISLNKrrrs rrnzTreeEntry.is_symlink<s dk) * **rc*|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)rrNs rrlzTreeEntry.statBs"<# 44rrA)rrrrrr r" stat_resultrr rr!rornrlrrrrSrSs  1& & &  &  &  &&&&P)))$)))) ))$)4)))) +++++ 5 5htn 5 5 5 5 5 5 5rrAr))@rr"os.pathpathlibrrlcollections.abcrrrr dataclassesrtypingrr r r r r r.r_typingrrr PathLikeStrPathrraltseprr|Pathr$tuplerrr1dictr>r7rGrKrRrmr\rZrOryr}r,rrrrr Exceptionrrirobjectr4rSrrrrs                                   R[%% & 7:W - - -vry!  #( $) ) E#w,' ()  ) tn)  8D>8C= () ) ) ) ) ^ $++ G + +tn+ #}  ++++\ G  %W (LLLLLL JLLLL26 $[[[ HgY_- .[~[k [[[[BL L L CH~L WItO $ L  L k LLLLb26 $YYY HgY_- .Y~Yc] YYYYD; ; ; CH~; WItO $ ;  ; c] ;;;;| # #6(G*;!< # # # #'*#$(  G   X >*.%%% jo &% %%%%P  *. jo & #tG}  H!.. .F8W,-. D>. ....>,,,,,Y,,,^77777Y777t $'(#>&0c5c5c5c5c5c5c5c5c5c5r