a e gX@sHdZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl mZddlmZddlmZmZmZm Z mZmZm Z mZmZmZmZmZmZmZmZddlmZej d kree!ee!fZ"n ee!efZ"ed e"d Z#d d ej$ej%fDZ&iZ'ej(e!dddZ)e ee*efe!eee+ee*fdddZ,dDe ee e!ee+ee!dfdddZ-e eeee*efdddZ.ee+dddZ/dEe"eee0gdfee+eddd d!Z1e!e!ee!e!fee0gdfe+edd"d#d$Z2dFe"eee0gdfee+ee!dd%d&Z3dGd'd(Z4e!eegefd)d*d+Z5e ee!e+dd,d-Z6e ee e!ee!d.d/d0Z7dHe"ee e!e!d1d2d3Z8dIe e"ee e!ee!ee"fd4d5d6Z9dJe!eegefee+dd7d8d9Z:Gd:d;d;e;Zd?Gd@dAdAee#Z>GdBdde?Z@GdCdde?ZAdS)KzC This module provides utility methods for dealing with path-specs. N) CollectionIterable) dataclass)PathLike)AnyAnyStrCallablerDictGenericrIteratorListOptionalSequenceSetTupleTypeVarUnion)Pattern) TStrPath)boundcCsg|]}|r|tjkr|qS) posixpathsep).0Z__seprrP/var/www/html/llm_bihealth/app/venv/lib/python3.9/site-packages/pathspec/util.py 1sr)pathreturncCst|}|r|tj7}|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)rZstr_pathrrrappend_dir_sepDs  r$)patternsfiler cCs@d}d}|D]*\}}|jdur ||dur |j}|}q ||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&Z out_includeZ out_indexindexpatternrrrcheck_match_fileVs r, MatchDetail)r%files all_matchesr c Cst|tr|nt|}i}|D]v}|jdur||}|jr|D]@}||vrr|rb||j|q|||jd<q@t|g||<q@q|D] }||=qq|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%appendr-) r%r.r/ all_files return_filesr+Z result_filesZ result_filer&rrrdetailed_match_filesrs   r7r%r cCsddt|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`). cSs"g|]\}}|jdur||fqSNr()rZ__index__patrrrrs z*_filter_check_patterns..) enumerater%rrr_filter_check_patternss r>)valuer cCst|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`). )r0 IterableTyper!bytes)r?rrr _is_iterablesrB TreeEntry)rooton_error follow_linksr ccsN|dur t|s td|d|dur,d}ttj|di||EdHdS)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#rabspathrDrErFrrriter_tree_entriess rN) root_fulldir_relmemorErFr c cstj||}tj|}||vr,|||<nt||||dt|:}|D]"}tj||j} z|jdd} Wn@ty} z(|dur|| WYd} ~ qPWYd} ~ n d} ~ 00| rz |} WnBty} z(|dur|| WYd} ~ qPWYd} ~ n d} ~ 00n| } |j |drPt |j| | | Vt || |||EdHqP| sb| rPt |j| | | VqPWdn1s0Y||=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#rjoinrealpathRecursionErrorscandirnamestatOSError is_symlinkr"rCrKis_file) rOrPrQrErFZdir_fullZdir_realZ scan_iterZnode_entZnode_relZ node_lstate node_statrrrrKs8   "  $4rKccs*t|||dD]}||s|jVqdS)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*. rErFN)rNr"r)rDrErFentryrrriter_tree_files3s rccCstjdtddt|||dS)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. stacklevelra)warningswarnDeprecationWarningrcrMrrr iter_treeRs rj)rZr cCst|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)rZrrrlookup_pattern]s rlcCs0d}|D]"}|jdur||dur|j}q|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`. FNr')r%r&matchedr+rrrr)is r))r%r.r cCsRtjtdtdtdddd|D}t}|D]}t||r4||q4|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.rdrecSsg|]}|jdur|qSr9r:)rr;rrrrzmatch_files..)rgrh__name__risetr)add)r%r.Z use_patternsr6r&rrr match_files}s  rr)r& separatorsr cCs`|dur t}t|}|D]}||tj}q|drF|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./rd)NORMALIZE_PATH_SEPSr#fspathreplacerr startswith)r&rs norm_filerrrrnormalize_files    rz)r.rsr cCsPtjdtddi}|D]2}t||d}||vr@|||q|g||<q|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.rdre)rs)rgrhrirzr4)r.rsZ norm_filesrryrrrnormalize_filess  r{)rZpattern_factoryoverrider cCsXt|tstd|dt|s2td|d|tvrL|sLt|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:rGN)r0r!rJrIrkAlreadyRegisteredError)rZr|r}rrrregister_patterns  rcsteZdZdZeeegefddfdd Ze edddZ e edd d Z e eegefdd d Z Z S) r~z| The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory is registered under a name already in use. N)rZr|r cstt|||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__)selfrZr| __class__rrrs zAlreadyRegisteredError.__init__r cCsdj|j|jdS)4 *message* (:class:`str`) is the error message. zG{name!r} is already registered for pattern factory:{pattern_factory!r}.)rZr|)formatrZr|rrrrmessage szAlreadyRegisteredError.messagecCs |jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrrrrrZ*szAlreadyRegisteredError.namecCs |jdS)za *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrrrrrr|1sz&AlreadyRegisteredError.pattern_factory)ro __module__ __qualname____doc__r!rrrrpropertyrrZr| __classcell__rrrrr~ s  r~csteZdZdZeeeddfdd ZeedddZeedd d Zeedd d Z eedd dZ Z S)rXzN The :exc:`RecursionError` exception is raised when recursion is detected. N)rRrSrTr cstt||||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)rrXr)rrRrSrTrrrr@szRecursionError.__init__rcCs |jdS)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrrrrrrSTszRecursionError.first_pathcCsdj|j|j|jdS)rzDReal path {real!r} was encountered at {first!r} and then {second!r}.)realfirstsecond)rrRrSrTrrrrr\s zRecursionError.messagecCs |jdS)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrrrrrrRgszRecursionError.real_pathcCs |jdS)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. rdrrrrrrToszRecursionError.second_path) rorrrr!rrrSrrRrTrrrrrrX:s rXT)frozenc@s6eZdZUdZdZeed<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) rorrr __slots__r__annotations__r boolintrrrrrxs   rc@s(eZdZdZdZeeddddZdS)r-z> The :class:`.MatchDetail` class contains information about r=Nr8cCs ||_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. Nr=)rr%rrrrs zMatchDetail.__init__)rorrrrrrrrrrrr-sc@seZdZdZdZeeejejddddZde e e ddd Z de e e dd d Z e d d dZ de e ejdddZdS)rCzR The :class:`.TreeEntry` class contains information about a file-system entry. _lstatrZr_statN)rZrlstatr[r cCs||_||_||_||_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)rrZrrr[rrrrs zTreeEntry.__init__)rFr cCs(|dur d}|r|jn|j}t|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_moderrFr`rrrr"s zTreeEntry.is_dircCs(|dur d}|r|jn|j}t|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_ISREGrrrrrr^s zTreeEntry.is_filercCst|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )r[S_ISLNKrrrrrrr]szTreeEntry.is_symlinkcCs|dur 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`). NT)rr)rrFrrrr[ s zTreeEntry.stat)N)N)N)rorrrrr!r# stat_resultrr rr"r^r]r[rrrrrCs +)N)NN)NN)NN)N)N)N)Brr#os.pathpathlibrr[sysrgcollections.abcrr1rr@Z dataclassesrrtypingrrrr r r r r rrrrrr+r version_infor!ZStrPathrraltseprurkPathr$rrr,r7r>rBr\rNrKrcrjrlr)rrrzr{r Exceptionr~rXrobjectr-rCrrrrs  D        /   $   S    #  *  (  />