yIfX ZdZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl mZddlmZddlmZmZmZm Z mZmZm Z mZmZmZmZmZmZmZmZddlmZej d kree!ee!fZ"n ee!efZ"ed e" Z# d ej$ej%fDZ& iZ' d ej(de!fdZ)de ee*efde!deee+ee*ffdZ, d9de ede e!dee+dee!dffdZ-de edeee*effdZ.dede+fdZ/ d:de"deee0gdfdee+dedfdZ1de!d e!d!ee!e!fdee0gdfde+dedf d"Z2 d:de"deee0gdfdee+dee!fd#Z3d:d$Z4d%e!deegeffd&Z5de ede!de+fd'Z6de ede e!dee!fd(Z7 d9de"d)ee e!de!fd*Z8 d9de e"d)ee e!dee!ee"ffd+Z9 d9d%e!d,eegefd-ee+ddfd.Z:Gd/d0e;Z<Gd1d2e;Z=ed34Gd5d6ee#Z>Gd7de?Z@Gd8de?ZAdS);zC This module provides utility methods for dealing with path-specs. N) CollectionIterable) dataclass)PathLike)AnyAnyStrCallablerDictGenericrIteratorListOptionalSequenceSetTupleTypeVarUnion)Pattern) TStrPath)boundc6g|]}|r|tjk|S) posixpathsep).0__seps A/var/www/piapp/venv/lib/python3.11/site-packages/pathspec/util.py r!1s9  y}$$$$$pathreturncjt|}|r|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_dirosr)r#str_paths r append_dir_sepr*Ds0 IIKKMM bf(r"patternsfilecld}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 actual pattern (:class:`~pathspec.pattern.Pattern`). *file* (:class:`str`) is the normalized file path to be matched against *patterns*. 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`). Ninclude match_file)r+r, out_include out_indexindexpatterns r check_match_filer5VsT$ $ ^UG _ W%7%7%=%=%I;9Yr"files 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:`~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:`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) isinstanceCollectionTypelistr/matchr+appendr8) r+r6r7 all_files return_filesr4 result_files result_filer,s r detailed_match_filesrCrs,!77 HUUT%[[W _ -- **< o#99 |## 7K )009999/6|K )!,,"-wi"8"8l;9 d  r"c4dt|DS)a& Filters out null-patterns. *patterns* (:class:`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:`~pathspec.pattern.Pattern`). c*g|]\}}|j ||fSNr/)r__index__pats r r!z*_filter_check_patterns..s3   gu ] Er") enumerater+s r _filter_check_patternsrLs+  !(++   r"valuecft|tot|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: IterableTyper&bytes)rMs r _is_iterablerQs* 5,''O 53,0O0O,OOr"rooton_error follow_links 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*. Nz on_error: is not callable.T)callable TypeError_iter_tree_entries_nextr(r#abspathrRrSrTs r iter_tree_entriesr^s|4 (!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)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)r(r#joinrealpathRecursionErrorscandirnamestatOSError is_symlinkr'rUr[is_file) r_r`rarSrTdir_fulldir_real scan_iternode_entnode_rel node_lstate node_stats r r[r[s}6 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#pKt|||D] }||s |jV!dS)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*. rSrTN)r^r'r#)rRrSrTentrys r iter_tree_filesr{3sS4 xlSSSU l # # r"c^tjdtdt|||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. stacklevelry)warningswarnDeprecationWarningr{r]s r iter_treerRs<  G1&&&& xlKKKKr"rkct|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 r lookup_patternr]s T""r"cZd}|D]%}|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`. Fr.)r+r,matchedr4s r r0r0is@ W _ W%7%7%=%=%I _7r"ctjtdtdtdd|D}t }|D]'}t ||r||(|S)a DEPRECATED: This is an old function no longer used. Use the :func:`~pathspec.util.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`). z".match_files() is deprecated. Use z-.match_file() with a loop for better results.r}r~c g|] }|j | SrFrG)rrIs r r!zmatch_files..sJJJ5 0I0I0I0Ir")rr__name__rsetr0add)r+r6 use_patternsr@r,s r match_filesr}s$       1&&&& KJHJJJ T d##Dr" separatorsc|t}tj|}|D]"}||tj}#|dr |dd}n|dr |dd}|S)ay 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 ``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 ``NORMALIZE_PATH_SEPS``. To prevent normalization, pass an empty container (e.g., an empty tuple ``()``). Returns the normalized file path (:class:`str`). N/rz./r})NORMALIZE_PATH_SEPSr(fspathreplacerr startswith)r,r norm_filers r normalize_filers("*)D// 44SY]33)) m))4  m)r"ctjdtdi}|D]9}t||}||vr|||3|g||<:|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.r}r~)r)rrrrr>)r6r norm_filesr#rs r normalize_filesrs* $1&&&&  ""TTj999)* i%%%% 6:ir"pattern_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:rWN)r:r&rZrYrAlreadyRegisteredError)rkrrs r register_patternrs( 453$333444!!KI_IIIJJJ    t%9$%?@@@-dr"ceZdZdZdedeegefddffd 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. rkrr$NcZtt|||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. N)superr__init__)selfrkr __class__s r rzAlreadyRegisteredError.__init__s,%%..t_EEEEEr"cDd|j|jS)4 *message* (:class:`str`) is the error message. zG{name!r} is already registered for pattern factory:{pattern_factory!r}.)rkr)formatrkrrs r messagezAlreadyRegisteredError.message s. S Y Y ' Z  r"c|jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrs r rkzAlreadyRegisteredError.name*s 1r"c|jdS)za *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrrs r rz&AlreadyRegisteredError.pattern_factory1 1r")r __module__ __qualname____doc__r&r rrrpropertyrrkr __classcell__rs@r rr s F  FVHg-. F F F F F F F c ( 3 (  hx'89 (r"rceZdZdZdedededdffd ZedefdZedefd Zedefd Z edefd Z xZ S) rizN The :exc:`RecursionError` exception is raised when recursion is detected. rcrdrer$Nc\tt||||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*. N)rrir)rrcrdrers r rzRecursionError.__init__@s-$&&y*kJJJJJr"c|jdS)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrs r rdzRecursionError.first_pathTrr"cPd|j|j|jS)rzDReal path {real!r} was encountered at {first!r} and then {second!r}.)realfirstsecond)rrcrdrers r rzRecursionError.message\s3 P V V     W  r"c|jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrs r rczRecursionError.real_pathgrr"c|jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. r}rrs r rezRecursionError.second_pathorr") rrrrr&rrrdrrcrerrs@r riri:s K KK K  KKKKKK(  ( c (  ( # (r"riT)frozencReZdZUdZdZeed< eeed< ee ed<dS) CheckResultze The :class:`CheckResult` class contains information about the file and which pattern matched it. )r,r/r3r,r/r3N) rrrr __slots__r__annotations__rboolintrr"r rrxs`   4.  r"rc2eZdZdZdZdeeddfdZdS)r8z> The :class:`.MatchDetail` class contains information about rKr+r$Nc||_dS)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. NrK)rr+s r rzMatchDetail.__init__s$-r")rrrrrrrrrr"r r8r8sL hw/Dr"c eZdZdZdZdededejdejddf d Zdd e e de fd Z dd e e de fd Z de fd Z dd e e dejfdZdS)rUzR The :class:`.TreeEntry` class contains information about a file-system entry. _lstatrkr#_statrkr#lstatrlr$NcD||_ ||_ ||_ ||_dS)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)rrkr#rrls r rzTreeEntry.__init__s?*!&$+ $)$) $$*r"rTc\|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_moderrTrws r r'zTreeEntry.is_dir4<(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)rrrlS_ISREGrrs r rozTreeEntry.is_filerr"c>tj|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )rlS_ISLNKrrrs r rnzTreeEntry.is_symlinks 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)rrTs r rlzTreeEntry.stat s"<# 44r"rF)rrrrrr&r( stat_resultrrrr'rornrlrr"r rUrUs  1) ) )  )  )  ))))V)))$)))) ))$)4)))) +++++ 5 5htn 5 5 5 5 5 5 5r"rF)NN)Brr(os.pathpathlibrrlsysrcollections.abcrr;rrO dataclassesrrtypingrrr r r r r rrrrrrr4r version_infor&StrPathrraltseprrPathr*rrr5rCrLrQrmr^r[r{rrr0rrrr Exceptionrrirobjectr8rUrr"r rs              "      v hsm# $ h  7:W - - -vry!  #$ E#w,' (  8D>8C= ()> $++ G + +tn+ #}  ++++\ G  %W (PPPPPP26 $ [ [ [ HgY_- . [~ [k [ [ [ [FN N N CH~N WItO $ N  N k NNNNf26 $ HgY_- .~c] >LLLL # #6(G*;!< # # # #'*#$( G   XF*.%%% jo &% %%%%T*.""" jo &" #tG} """"P!.. .F8W,-. D>. ....@,,,,,Y,,,^;;;;;Y;;;| $'(#>&2g5g5g5g5g5g5g5g5g5g5r"