ni/;dZddlmZddlmZmZmZmZddlm Z ddl m Z m Z m Z mZmZe ddZ dd lmZdd lmZmZdd lmZdd lmZdd lmZmZddlmZmZm Z m!Z!m"Z"m#Z#Gdde$Z%dS)zn This module provides :class:`.PathSpec` which is an object-oriented interface for pattern matching of files. ) annotations) CollectionIterableIteratorSequence) zip_longest)CallableOptionalTypeVarUnioncastSelfPathSpec)bound)util)_BackendBackendNamesHintmake_pathspec_backend)Pattern)AnyStr deprecated) CheckResultStrPathTStrPath TreeEntry _is_iterablenormalize_filec"eZdZdZddddDd ZdEdZdFdZdEdZdGdZ dHdIdZ dHdJd Z dKdLd(Z e ddddMd/Z edNd4Z dHdd5dOd:Z dHdPd;Z dHdd5dQd>Z dKdd5dRd?Zed@dSdBZ dKdd5dTdCZdS)Urzd The :class:`PathSpec` class is a wrapper around a list of compiled :class:`.Pattern` instances. Nbackend_test_backend_factorypatterns+Union[Sequence[Pattern], Iterable[Pattern]]r!"Union[BackendNamesHint, str, None]r"1Optional[Callable[[Sequence[Pattern]], _Backend]]returnNonect|tst|}|d}tt|}| ||}n|||}||_ ||_ ||_dS)a Initializes the :class:`.PathSpec` instance. *patterns* (:class:`~collections.abc.Sequence` or :class:`~collections.abc.Iterable`) contains each compiled pattern (:class:`.Pattern`). If not a sequence, it will be converted to a :class:`list`. *backend* (:class:`str` or :data:`None`) is the pattern (regular expression) matching backend to use. Default is :data:`None` for "best" to use the best available backend. Priority of backends is: "re2", "hyperscan", "simple". The "simple" backend is always available. Nbest) isinstancerlistr r _make_backend_backend _backend_namer#)selfr#r!r" use_backends N/var/www/html/gpu-tools/venv/lib/python3.11/site-packages/pathspec/pathspec.py__init__zPathSpec.__init__5s& Hh ' '8nn8 _ 7 !7 + +'&&&x00;;##GX66;'$- *1$&.$-r0rotherct|tr)||j|jz|jSt S)zn Combines the :attr:`self.patterns <.PathSpec.patterns>` patterns from two :class:`PathSpec` instances. )r!)r+r __class__r#r/NotImplementedr0r5s r2__add__zPathSpec.__add__es> x   ..7AS. T TT r4objectboolct|tr3t|j|j}t d|DSt S)z Tests the equality of this path-spec with *other* (:class:`PathSpec`) by comparing their :attr:`self.patterns <.PathSpec.patterns>` attributes. c3(K|] \}}||kVdSN).0abs r2 z"PathSpec.__eq__..vs* 1 1Aa1f 1 1 1 1 1 1r4)r+rrr#allr8)r0r5paired_patternss r2__eq__zPathSpec.__eq__osL x   ??? 1 1 1 1 1 1 11 r4ct|tr<|xj|jz c_||j|j|_|St S)zn Adds the :attr:`self.patterns <.PathSpec.patterns>` from *other* (:class:`PathSpec`) to this instance. )r+rr#r-r/r.r8r9s r2__iadd__zPathSpec.__iadd__zsO x  ==EN"==%%d&8$-HH4= ; r4intc*t|jS)zp Returns the number of :attr:`self.patterns <.PathSpec.patterns>` this path-spec contains (:class:`int`). )lenr#)r0s r2__len__zPathSpec.__len__s T]  r4filer separatorsOptional[Collection[str]]CheckResult[TStrPath]c~t||}|j|\}}t|||S)a Check the files against this path-spec. *file* (:class:`str` or :class:`os.PathLike`) is the file path to be matched against :attr:`self.patterns <.PathSpec.patterns>`. *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 the file check result (:class:`.CheckResult`). )rr. match_filer)r0rNrO norm_fileincludeindexs r2 check_filezPathSpec.check_files>"T:..)=++I66.'5 T7E * **r4filesIterable[TStrPath]Iterator[CheckResult[TStrPath]]c#Kt|std|d|D]B}t||}|j|\}}t |||VCdS)a Check the files against this path-spec. *files* (:class:`~collections.abc.Iterable` of :class:`str` or :class:`os.PathLike`) contains the file paths to be checked against :attr:`self.patterns <.PathSpec.patterns>`. *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 an :class:`~collections.abc.Iterator` yielding each file check result (:class:`.CheckResult`). files: is not an iterable.N)r TypeErrorrr.rSr)r0rXrO orig_filerTrUrVs r2 check_fileszPathSpec.check_filess& e  ; 9E999 : ::00ii449M,,Y77>7E Y / /////00r4rootron_error#Optional[Callable[[OSError], None]] follow_linksOptional[bool]Iterator[CheckResult[str]]c#nKtj|||}||Ed{VdS)a Walks the specified root path for all files and checks them against this path-spec. *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`. *negate* (:class:`bool` or :data:`None`) is whether to negate the match results of the patterns. If :data:`True`, a pattern matching a file will exclude the file rather than include it. Default is :data:`None` for :data:`False`. Returns an :class:`~collections.abc.Iterator` yielding each file check result (:class:`.CheckResult`). rbrdN)riter_tree_filesr`)r0rarbrdrXs r2check_tree_fileszPathSpec.check_tree_filessK<  th\ R R R%   e $ $$$$$$$$$$r4cls type[Self]pattern_factory'Union[str, Callable[[AnyStr], Pattern]]linesIterable[AnyStr]cttrtjt st ddt |st d|dfd|D}||||S)a Compiles the pattern lines. *pattern_factory* can be either the name of a registered pattern factory (:class:`str`), or a :class:`~collections.abc.Callable` used to compile patterns. It must accept an uncompiled pattern (:class:`str`) and return the compiled pattern (:class:`.Pattern`). *lines* (:class:`~collections.abc.Iterable`) yields each uncompiled pattern (:class:`str`). This simply has to yield each line so that it can be a :class:`io.TextIOBase` (e.g., from :func:`open` or :class:`io.StringIO`) or the result from :meth:`str.splitlines`. *backend* (:class:`str` or :data:`None`) is the pattern (or regular expression) matching backend to use. Default is :data:`None` for "best" to use the best available backend. Priority of backends is: "re2", "hyperscan", "simple". The "simple" backend is always available. Returns the :class:`PathSpec` instance. zpattern_factory:z is not callable.zlines:r]c*g|]}||Sr@r@)rAlinerms r2 z'PathSpec.from_lines..s( > > > >ood## > > >r4r )r+strrlookup_patterncallabler^r)rkrmror!r"r#s ` r2 from_lineszPathSpec.from_liness:%%:(99? / " "L JoJJJ K KK e  ; 9E999 : :: > > > > > > >( Xw>S T T TTr4namerSequence[Pattern]rc"t||S)aM .. warning:: This method is not part of the public API. It is subject to change. Create the backend for the patterns. *name* (:class:`str`) is the name of the backend. *patterns* (:class:`~collections.abc.Sequence` of :class:`.Pattern`) contains the compiled patterns. Returns the matcher (:class:`._Backend`). r)ryr#s r2r-zPathSpec._make_backends$ tX . ..r4negateentriesIterable[TreeEntry]r}Iterator[TreeEntry]c#Kt|std|d|D]?}t|j|}|j|\}}|r| }|r|V@dS)a Matches the entries to this path-spec. *entries* (:class:`~collections.abc.Iterable` of :class:`.TreeEntry`) contains the entries to be matched against :attr:`self.patterns <.PathSpec.patterns>`. *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. *negate* (:class:`bool` or :data:`None`) is whether to negate the match results of the patterns. If :data:`True`, a pattern matching a file will exclude the file rather than include it. Default is :data:`None` for :data:`False`. Returns the matched entries (:class:`~collections.abc.Iterator` of :class:`.TreeEntry`). zentries:r]N)rr^rpathr.rS)r0r~rOr}entryrTrU_indexs r2 match_entrieszPathSpec.match_entriess2 g  ? =g=== > >>eej*559]--i88?7F kG  KKKr4czt||}|j|\}}t|S)a Matches the file to this path-spec. *file* (:class:`str` or :class:`os.PathLike`) is the file path to be matched against :attr:`self.patterns <.PathSpec.patterns>`. *separators* (:class:`~collections.abc.Collection` of :class:`str`) optionally contains the path separators to normalize. See :func:`.normalize_file` for more information. Returns :data:`True` if *file* matched; otherwise, :data:`False`. )rr.rSr<)r0rNrOrTrUrs r2rSzPathSpec.match_fileAs8"T:..)M,,Y77/'6 gr4Iterable[StrPath]Iterator[StrPath]c#Kt|std|d|D]:}t||}|j|\}}|r| }|r|V;dS)a Matches the files to this path-spec. *files* (:class:`~collections.abc.Iterable` of :class:`str` or :class:`os.PathLike`) contains the file paths to be matched against :attr:`self.patterns <.PathSpec.patterns>`. *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. *negate* (:class:`bool` or :data:`None`) is whether to negate the match results of the patterns. If :data:`True`, a pattern matching a file will exclude the file rather than include it. Default is :data:`None` for :data:`False`. Returns the matched files (:class:`~collections.abc.Iterator` of :class:`str` or :class:`os.PathLike`). r\r]N)rr^rr.rS)r0rXrOr}r_rTrUrs r2 match_fileszPathSpec.match_filesVs4 e  ; 9E999 : ::ii449]--i88?7F kG  OOOr4c#rKtj|||}|||Ed{VdS)a Walks the specified root path for all files and matches them to this path-spec. *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`. *negate* (:class:`bool` or :data:`None`) is whether to negate the match results of the patterns. If :data:`True`, a pattern matching a file will exclude the file rather than include it. Default is :data:`None` for :data:`False`. Returns the matched files (:class:`~collections.abc.Iterator` of :class:`.TreeEntry`). rhr|N)riter_tree_entriesr)r0rarbrdr}r~s r2match_tree_entrieszPathSpec.match_tree_entries}sQ@  "4( V V V'     7 7777777777r4zEPathSpec.match_tree() is deprecated. Use .match_tree_files() instead. Iterator[str]c|j|i|S)z .. version-deprecated:: 0.3.2 This is an alias for the :meth:`self.match_tree_files <.PathSpec.match_tree_files>` method. )match_tree_files)r0argskws r2 match_treezPathSpec.match_trees   + + ++r4c#rKtj|||}|||Ed{VdS)a Walks the specified root path for all files and matches them to this path-spec. *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`. *negate* (:class:`bool` or :data:`None`) is whether to negate the match results of the patterns. If :data:`True`, a pattern matching a file will exclude the file rather than include it. Default is :data:`None` for :data:`False`. Returns the matched files (:class:`~collections.abc.Iterable` of :class:`str`). rhr|N)rrir)r0rarbrdr}rXs r2rzPathSpec.match_tree_filessP>  th\ R R R%   eF  3 3333333333r4)r#r$r!r%r"r&r'r()r0rr5rr'r)r5r;r'r<)r'rJr?)rNrrOrPr'rQ)rXrYrOrPr'rZ)NN)rarrbrcrdrer'rf) rkrlrmrnrorpr!r%r"r&r'r)ryrr#rzr'r)r~rrOrPr}rer'r)rNrrOrPr'r<)rXrrOrPr}rer'r) rarrbrcrdrer}rer'r)r'r) rarrbrcrdrer}rer'r)__name__ __module__ __qualname____doc__r3r:rGrIrMrWr`rj classmethodrx staticmethodr-rrSrrrrrr@r4r2rr/sY15MQ ......`        +/+++++0+/00000<37!% %%%%%B 15MQ &U&U&U&U&U+&UP///,/,+/$  $$$$$$R+/0+/%  %%%%%%T37!% !8  !8!8!8!8!8!8H *I,,,,37!% 4  4 4 4 4 4 4 4 4r4N)&r __future__rcollections.abcrrrr itertoolsrtypingr r r r r rpathspecrpathspec.backendrrpathspec._backends.aggrpathspec.patternrpathspec._typingrr pathspec.utilrrrrrrr;rr@r4r2rs #"""""            wvZ(((               ]4]4]4]4]4v]4]4]4]4]4r4