o bi F@sdZddlZddlZddlZddlZddlmZmZmZm Z ddej ej fDZ iZ d'ddZd d Zd(d d Zd(d dZeZddZddZddZddZd'ddZd'ddZd'ddZd'ddZGdd d eZGd!d"d"eZGd#d$d$eZGd%d&d&eZ dS))zC This module provides utility methods for dealing with path-specs. N) CollectionIterable string_typesunicodecCsg|] }|r|tjkr|qS) posixpathsep).0r rrY/home/ubuntu/.local/lib/python3.10/site-packages/ray/_private/thirdparty/pathspec/util.py sr c Cst|tr|nt|}i}|D];}|jdurJ||}|jrB|D] }||vr9|r1||j|q |||jd<q t|g||<q q|D]}||=qDq|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:`boot` 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) isinstancerlistincludematchpatternsappend MatchDetail) rfiles all_matches all_files return_filespattern result_files result_filefilerrr detailed_match_filess"   rcCst|to t|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 rrbytes)valuerrr _is_iterableFsrccsT|durt|std||durd}ttj|di||D]}|Vq"dS)a Walks the specified directory for all files and directories. *root* (:class:`str`) 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.Iterable` yielding each file or directory entry (:class:`.TreeEntry`) relative to *root*. Non_error:{!r} is not callable.T)callable TypeErrorformat_iter_tree_entries_nextospathabspathrooton_error follow_linksentryrrr iter_tree_entriesQsr.ccs`|durt|std||durd}ttj|di||D] }||s-|jVq"dS)a Walks the specified directory for all files. *root* (:class:`str`) 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.Iterable` yielding the path to each file (:class:`str`) relative to *root*. Nr Tr!)r"r#r$r%r&r'r(is_dirr)rrr iter_tree_filesps r0c csxtj||}tj|}||vr|||<n t||||dt|D]}tj||}tj||} zt| } WntyV} z|durL|| WYd} ~ q%d} ~ wwt | j rd} zt| } Wnty} z|durv|| WYd} ~ q%d} ~ wwd} | } t | j r|s| st ||| | Vt |||||D]}|Vqq%t| j s| rt ||| | Vq%||=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_pathNTF)r&r'joinrealpathRecursionErrorlistdirlstatOSErrorstatS_ISLNKst_modeS_ISDIR TreeEntryr%S_ISREG) root_fulldir_relmemor+r,dir_fulldir_real node_namenode_rel node_full node_lstateis_link node_statr-rrr r%sL      r%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)namerrr lookup_patterns rNcCs2d}|D]}|jdur|||fvr|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`. FN)rr)rrmatchedrrrr match_files  rPcCsZt|tr|nt|}t}|D]}|jdur*||}|jr%||q||q|S)a^ 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`). N)r rrsetrrupdatedifference_update)rrrrrrrrr match_filess     rTcCs$i}|D] }||t|j|d<q|S)a Normalizes the entry paths to use the POSIX path separator. *entries* (:class:`~collections.abc.Iterable` of :class:`.TreeEntry`) contains the entries 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 the each normalized file path (:class:`str`) to the entry (:class:`.TreeEntry`)  separators)normalize_filer')entriesrV norm_filesr-rrr _normalize_entriessrZcCsF|durt}t|}|D] }||tj}q |dr!|dd}|S)aS Normalizes the file path to use the POSIX path separator (i.e., ``'/'``). *file* (:class:`str` or :class:`pathlib.PurePath`) 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 :data:`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`). Nz./)NORMALIZE_PATH_SEPSstrreplacerr startswith)rrV norm_filer rrr rW-s  rWcCs"i}|D] }||t||d<q|S)a Normalizes the file paths to use the POSIX path separator. *files* (:class:`~collections.abc.Iterable` of :class:`str` or :class:`pathlib.PurePath`) 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 the each normalized file path (:class:`str`) to the original file path (:class:`str`) rU)rW)rrVrYr'rrr normalize_filesMsracCsTt|ts td|t|std||tvr$|s$t|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:{!r} is not a string.z%pattern_factory:{!r} is not callable.N)r rr#r$r"rLAlreadyRegisteredError)rMpattern_factoryoverriderrr register_patternas   recsDeZdZdZfddZeddZeddZedd ZZ S) rbz| The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory is registered under a name already in use. 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)superrb__init__)selfrMrc __class__rr rgs zAlreadyRegisteredError.__init__cCsdj|j|jdS)4 *message* (:class:`str`) is the error message. zG{name!r} is already registered for pattern factory:{pattern_factory!r}.)rMrc)r$rMrcrhrrr messageszAlreadyRegisteredError.messagecC |jdS)zB *name* (:class:`str`) is the name of the registered pattern. rargsrlrrr rMs zAlreadyRegisteredError.namecCrn)za *pattern_factory* (:class:`~collections.abc.Callable`) is the registered pattern factory. rrorlrrr rc z&AlreadyRegisteredError.pattern_factory) __name__ __module__ __qualname____doc__rgpropertyrmrMrc __classcell__rrrir rbzs   rbcsPeZdZdZfddZeddZeddZedd Zed d Z Z S) r6zN The :exc:`RecursionError` exception is raised when recursion is detected. 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)rfr6rg)rhr1r2r3rirr rgs zRecursionError.__init__cCrn)zx *first_path* (:class:`str`) is the first path encountered for :attr:`self.real_path `. rrorlrrr r2rqzRecursionError.first_pathcCsdj|j|j|jdS)rkzDReal path {real!r} was encountered at {first!r} and then {second!r}.)realfirstsecond)r$r1r2r3rlrrr rms zRecursionError.messagecCrn)zV *real_path* (:class:`str`) is the real path that recursion was encountered on. rrorlrrr r1rqzRecursionError.real_pathcCrn)zz *second_path* (:class:`str`) is the second path encountered for :attr:`self.real_path `. r[rorlrrr r3rqzRecursionError.second_path) rrrsrtrurgrvr2rmr1r3rwrrrir r6s    r6c@seZdZdZdZddZdS)rz> The :class:`.MatchDetail` class contains information about rcCs ||_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{)rhrrrr rgs zMatchDetail.__init__N)rrrsrtru __slots__rgrrrr rs rc@sBeZdZdZdZddZdddZddd Zd d Zdd d Z dS)r>zR The :class:`.TreeEntry` class contains information about a file-system entry. _lstatrMr'_statcCs"||_ ||_ ||_ ||_dS)aR 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})rhrMr'r8r:rrr rgszTreeEntry.__init__NcC(|durd}|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)rr~r:r=r<rhr,rKrrr r/%  zTreeEntry.is_dircCr)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)rr~r:r?r<rrrr is_file5rzTreeEntry.is_filecCst|jjS)zC Returns whether the entry is a symbolic link (:class:`bool`). )r:r;r~r<rlrrr is_symlinkEszTreeEntry.is_symlinkcCs|durd}|r |jS|jS)a: 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~)rhr,rrr r:Ks zTreeEntry.statN) rrrsrtrur|rgr/rrr:rrrr r>s % r>r)NN)!rur&os.pathrr:compatrrrrr altsepr\rLrrr.r0 iter_treer%rNrPrTrZrWrare Exceptionrbr6objectrr>rrrr s6 * !M    +9