jA"dZddlmZddlmZmZmZmZddlm Z ddl m Z m Z m Z mZmZmZmZmZeddZ dd lmZdd lmZmZmZdd lmZdd lmZdd lmZddl m!Z!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+Gdde e'Z,dS)zn This module provides :class:`.PathSpec` which is an object-oriented interface for pattern matching of files. ) annotations) CollectionIterableIteratorSequence) zip_longest)CallableGenericLiteralOptionalTypeVarUnioncastoverloadSelfPathSpec)bound)util)BackendNamesHint_Backend_TestBackendFactoryHintmake_pathspec_backend)Pattern)GitIgnoreBasicPattern)AnyStr deprecated) CheckResultStrPathTPattern TPattern_coTStrPath TreeEntry _is_iterablenormalize_fileceZdZdZddddPd ZdQdZdRdZdSdZdRdZdTdZ dUdVdZ dUdWd"Z dXdYd*Z e eddddZd2Ze edddd[d4Ze edddd\d7Ze edddd]d9Zedddd^d<Zed_dAZ dUddBd`dGZ dUdadHZ dUddBdbdJZ dXddBdcdKZedLdddNZ dXddBdedOZdS)frzd The :class:`PathSpec` class is a wrapper around a list of compiled :class:`.Pattern` instances. Nbackend_test_backend_factorypatterns3Union[Sequence[TPattern_co], Iterable[TPattern_co]]r("Union[BackendNamesHint, str, None]r)rreturnNonect|tr|}nt|}|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) isinstancerlistrr _make_backend_backend _backend_namer*)selfr*r(r) use_patterns backend_name use_backends [/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/pathspec/pathspec.py__init__zPathSpec.__init__=s&(##!<<x..< _ 7&00,&&&|44;;##L,??;'$- *6$*6$-strc@|jjd|jd|jdS)z7 Returns a debug representation of this path-spec. z (patterns=z , backend=)) __class____name__r*r5r6s r:__repr__zPathSpec.__repr__os- N # a at} a a$J\ a a aar<r6rotherct|tr*|g|j|j|jSt S)zn Combines the :attr:`self.patterns <.PathSpec.patterns>` patterns from two :class:`PathSpec` instances. )r()r1rr@r*r5NotImplementedr6rDs r:__add__zPathSpec.__add__usD x   ..:4=:5>:DDV. W WW r<objectboolct|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 r: z"PathSpec.__eq__..s* 1 1Aa1f 1 1 1 1 1 1r<)r1rrr*allrF)r6rDpaired_patternss r:__eq__zPathSpec.__eq__sL x   ??? 1 1 1 1 1 1 11 r<ct|tr` from *other* (:class:`PathSpec`) to this instance. )r1rr*r3r5r4rFrGs r:__iadd__zPathSpec.__iadd__sR x  4T]4U^44=%%d&8$-HH4= ; r<intc*t|jS)zp Returns the number of :attr:`self.patterns <.PathSpec.patterns>` this path-spec contains (:class:`int`). )lenr*rBs r:__len__zPathSpec.__len__s T]  r<filer" 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`). )r%r4 match_filer)r6r\r] norm_fileincludeindexs r: check_filezPathSpec.check_files>"T:..)=++I66.'5 T7E * **r<filesIterable[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$ TypeErrorr%r4rar)r6rfr] orig_filerbrcrds r: check_fileszPathSpec.check_filess& e  ; 9E999 : ::00ii449M,,Y77>7E Y / /////00r<rootron_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`). rprrN)riter_tree_filesrn)r6rorprrrfs r:check_tree_fileszPathSpec.check_tree_filessK<  th\ R R R%   e $ $$$$$$$$$$r<clstype[PathSpec]pattern_factoryLiteral['gitignore']linesIterable[AnyStr]PathSpec[GitIgnoreBasicPattern]cdSrMrNryr{r}r(r)s r: from_lineszPathSpec.from_lines #r<PathSpec[Pattern]cdSrMrNrs r:rzPathSpec.from_linesrr<type[TPattern]PathSpec[TPattern]cdSrMrNrs r:rzPathSpec.from_linesrr<Callable[[AnyStr], TPattern]cdSrMrNrs r:rzPathSpec.from_linesrr< type[Self]6Union[str, type[Pattern], Callable[[AnyStr], Pattern]]c"t|trtj|n%t |r|nt d|dt |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:rkc*g|]}||SrNrN)rO_PathSpec__line use_factorys r: z'PathSpec.from_lines..Fs( @ @ @f @kk&!! @ @ @r<r')r1r=rlookup_patterncallablerlr$)ryr{r}r(r)r*r6rs @r:rzPathSpec.from_liness<%%L$_55;;  L ;; JoJJJ K KK e  ; 9E999 : :: @ @ @ @ @ @ @( Xw>S T T T$ +r<namerSequence[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)rr*s r:r3zPathSpec._make_backendJs$ tX . ..r<negateentriesIterable[TreeEntry]rIterator[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:rkN)r$rlr%pathr4ra)r6rr]rentryrbrc_indexs r: match_entrieszPathSpec.match_entries^s2 g  ? =g=== > >>eej*559]--i88?7F kG  KKKr<czt||}|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`. )r%r4rarJ)r6r\r]rbrcrs r:razPathSpec.match_files8"T:..)M,,Y77/'6 gr<Iterator[TStrPath]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`). rjrkN)r$rlr%r4ra)r6rfr]rrmrbrcrs r: match_fileszPathSpec.match_filess4 e  ; 9E999 : ::ii449]--i88?7F kG  OOOr<c#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`). rvrN)riter_tree_entriesr)r6rorprrrrs r:match_tree_entrieszPathSpec.match_tree_entriessQ@  "4( V V V'     7 7777777777r<zEPathSpec.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)r6argskws r: match_treezPathSpec.match_trees   + + ++r<c#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`). rvrN)rrwr)r6rorprrrrfs r:rzPathSpec.match_tree_filessP>  th\ R R R%   eF  3 3333333333r<)r*r+r(r,r)rr-r.)r-r=)r6rrDrr-r)rDrIr-rJ)r-rXrM)r\r"r]r^r-r_)rfrgr]r^r-rh)NN)rorrprqrrrsr-rt) ryrzr{r|r}r~r(r,r)rr-r) ryrzr{r=r}r~r(r,r)rr-r) ryrzr{rr}r~r(r,r)rr-r) ryrzr{rr}r~r(r,r)rr-r) ryrr{rr}r~r(r,r)rr-r)rrr*rr-r)rrr]r^rrsr-r)r\rr]r^r-rJ)rfrgr]r^rrsr-r) rorrprqrrrsrrsr-r)r-r) rorrprqrrrsrrsr-r)rA __module__ __qualname____doc__r;rCrHrUrWr[rernrxr classmethodr staticmethodr3rrarrrrrrNr<r:rr7s[1537 000000dbbbb         +/+++++0+/00000<37!% %%%%%B  1537 + (  1537 + (  1537 + (  1537 + ( 1537 )))))+)V///,/,+/$  $$$$$$R+/0+/%  %%%%%%T37!% !8  !8!8!8!8!8!8H *I,,,,37!% 4  4 4 4 4 4 4 4 4r<N)-r __future__rcollections.abcrrrr itertoolsrtypingr r r r r rrrrpathspecrpathspec.backendrrrpathspec._backends.aggrpathspec.patternr!pathspec.patterns.gitignore.basicrpathspec._typingrr pathspec.utilrrr r!r"r#r$r%rrNr<r:rsk#"""""                                wvZ(((               X4X4X4X4X4w{#X4X4X4X4X4r<