intellecton/venv/lib/python3.12/site-packages/pathspec/__pycache__/util.cpython-312.pyc

<EFBFBD>
J<>j<>c<00>
<01><><00>UdZd
dl
mZ
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlm	Z	m
Z
mZmZ
d
dl
mZ
d
dlmZmZmZmZmZmZmZ
ddlmZ
dd	lmZmZ
eeej:efZed
e<18><0B>Z	eded
<0A><0E>Z 	ede<1E><0B>Z!	ejDejFfD<00>cgc]}|r|ejDk7r	ee|<00><00><02>c}Z$	iZ%de&d<	d0d<12>Z'	d1							d2d<13>Z(	d1							d3d<14>Z)				d4d<15>Z*d5d<16>Z+ed<17>
d6d<18>
<01>Z,		d6							d7d<19>Z-												d8d<1A>Z.		d6							d9d<1B>Z/												d:d<1C>Z0d;d<1D>Z1d<d<1E>Z2ed<1F>
						d=d <20><04>Z3	d1					d>d!<21>Z4ed"<22>
	d1					d?d#<23><05>Z5	d1							d@d$<24>Z6Gd%<25>d&e7<65>Z8Gd'<27>d(e7<65>Z9ed
<0A>)<29>
Gd*<2A>d+ee!<00><00>Z:Gd,<2C>d-e;<3B>Z<Gd.<2E>d/e;<3B>Z=yc
c}w)AzC
This module provides utility methods for dealing with path-specs.
<EFBFBD>)
<01>annotationsN)<04>
Collection<EFBFBD>Iterable<6C>Iterator<6F>Sequence)
<01>	dataclass)<07>Any<6E>Callable<6C>Generic<69>Optional<61>TypeVar<61>Union<6F>cast<73>
)
<01>Pattern)<02>AnyStr<74>
deprecated<EFBFBD>TPattern)
<01>bound<6E>TPattern_coT)r<00>	covariant<6E>TStrPathz1dict[str, Callable[[Union[str, bytes]], Pattern]]<5D>_registered_patternsc

<01>b<00>t
|<00>
}
|j<00>r|
tjz
}
|
S)
a4

	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`).
	)<04>str<74>is_dir<69>os<6F>sep)<02>path<74>str_paths  <20>P/home/antigravity/intellecton/venv/lib/python3.12/site-packages/pathspec/util.py<70>append_dir_sepr"Gs)<00><00>
<10><04>I<EFBFBD><18><08>K<EFBFBD>K<EFBFBD>M<EFBFBD>
<EFBFBD>b<EFBFBD>f<EFBFBD>f<EFBFBD><14>(<28><10><1F>c
<01><><00>|r9|D]3\}}|j<00>
<01>|j|
<01>
<00>
<01>%|j|fc
Syd
}d
}|D]2\}}|j<00>
<01>|j|
<01>
<00>
<01>%|j}|}<06>4||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 actua
	pattern (:class:`.Pattern`).

	*file* (:class:`str`) is the normalized file path to be matched against
	*patterns*.

	*is_reversed* (:class:`bool` or :data:`None`) is whether the order of the
	patterns has been reversed. Default is :data:`None` for :data:`False`.
	Reversing the order of the patterns is an optimization.

	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`).
	N<>NN<4E><02>include<64>
match_file)<07>patterns<6E>file<6C>is_reversed<65>index<65>pattern<72>out_include<64>	out_indexs       r!<00>check_match_filer0Xs<><00><00>.<10>!<21>"<22>n<EFBFBD>e<EFBFBD>W<EFBFBD>
<0A>o<EFBFBD>o<EFBFBD>!<21>g<EFBFBD>&8<>&8<><14>&><3E>&J<><12>?<3F>?<3F>E<EFBFBD>!<21>!<21>"<22>
<14>!%<25>+<2B>!<21>)<29> <20><16>n<EFBFBD>e<EFBFBD>W<EFBFBD>
<0A>o<EFBFBD>o<EFBFBD>!<21>g<EFBFBD>&8<>&8<><14>&><3E>&J<><19>/<2F>/<2F>K<EFBFBD><15>I<EFBFBD><16>

<15>i<EFBFBD>	<1F>r#c
<01>X
<00>t
|
t<00>r|
n
t|
<01>
}i}|D]<5D>}|j<00>
<01>|j	|<03>
}|jrO|D]I}||vr4|r||j
j
|<05>

<00>(|||j
d
<<00>;t|g
<01>
||<<00>K<00>||D]}||=<00><00><>|S)a<>
	Matches the files to the patterns, and returns which patterns matched the
	files.

	*patterns* (:class:`~collections.abc.Iterable` of :class:`.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`).
	r)<08>
isinstancer<00>listr'<00>matchr)<00>append<6E>MatchDetail)	r)<00>files<65>all_matches<65>	all_files<65>return_filesr-<00>result_files<65>result_filer*s	         r!<00>detailed_match_filesr=<00>s<><00><00>,!<21><15>
<EFBFBD>3<>U<EFBFBD><14>e<EFBFBD><1B><19>(*<2A><1C><18><1C>W<EFBFBD><0C>_<EFBFBD>_<EFBFBD> <20><19>-<2D>-<2D>	<09>*<2A><<3C>
<0A>o<EFBFBD>o<EFBFBD>#<23>9<><0B><13>|<7C>#<23>	<14><13>K<EFBFBD> <20>)<29>)<29>0<>0<><17>9<>/6<>|<7C>K<EFBFBD> <20>)<29>)<29>!<21>,<2C>"-<2D>w<EFBFBD>i<EFBFBD>"8<>l<EFBFBD>;<3B><1F>9<><1D>
<1C><04>	<15>d<EFBFBD>	<1B>
<1C>#<1C>(	<15>
r#c

<01>f<00>t
|<00>
D<00>
<01>cgc]\}
}|j<00>|
|f<02><02>c}}
Sc
c}}
w)
a&

	Filters out null-patterns.

	*patterns* (:class:`~collections.abc.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:`.Pattern`).
	)<02>	enumerater')r)<00>__index<65>__pats   r!<00>_filter_check_patternsrB<00>s<<00><00>"<22>(<28>+<2B>	<03><14>g<EFBFBD>u<EFBFBD>
<EFBFBD>]<5D>]<5D><1E><0B>E<EFBFBD><12>	<03><03><>	s<00>-c

<01>T<00>t
|t<00>x
r
t
|ttf<02>S)
z<>
	Check whether the value is an iterable (excludes strings).

	*value* is the value to check,

	Returns whether *value* is an iterable (:class:`bool`).
	)r2rr<00>bytes)
<01>values
 r!<00>_is_iterablerF<00>s$<00><00>	<13>5<EFBFBD>(<28>#<23>K<>J<EFBFBD>u<EFBFBD>s<EFBFBD>E<EFBFBD>l<EFBFBD>,K<>(K<>
Kr#zGpathspec.util.iter_tree() is deprecated. Use iter_tree_files() instead.c
<01><00>t
||
|<02>
<01>S)z`
	.. version-deprecated:: 0.10.0
		This is an alias for the :func:`.iter_tree_files` function.
	)<02>on_error<6F>follow_links)
<01>iter_tree_files<65><03>rootrHrIs   r!<00>	iter_treerM<00>s<00><00>	<18><04>x<EFBFBD>l<EFBFBD>K<>
Kr#c#
<01><>K
<00>|
<01>t
|
<01>
std|
<01>d<03><03>
<00>
|<02>d}ttjj|<00>
di|
|<02>Ed
{<00><02><02>
y
7<00><05>w
)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*.
	N<>	on_error:<3A> is not callable.T<>)<06>callable<6C>	TypeError<6F>_iter_tree_entries_nextrr<00>abspathrKs   r!<00>iter_tree_entriesrV<00>sX<00><00><><00>0
<0A><18><18>(<28>!3<><11>I<EFBFBD>h<EFBFBD>\<5C>):<3A>;<3B><<3C><<3C><10><18><15>,<2C>#<23>B<EFBFBD>G<EFBFBD>G<EFBFBD>O<EFBFBD>O<EFBFBD>D<EFBFBD>$9<>2<EFBFBD>r<EFBFBD>8<EFBFBD>\<5C>Z<>
Z<>
Z<><5A><00>AA
<01>
A<04>A
c	#
<01>xK
<00>tjj||
<01>}tjj|<05>
}||v
r|
||<nt	||||
<01>
<01><00>
t
j
|<05>
5}|D]<5D>}tjj|
|j<00>}		|jd<02><03>
}
|j<00>r	|j<00>}n|
}|j|<04><03>
r2t|j|	|
|<0C><00><02>

t||	|||<04>Ed{<00><03><02>
<00><>|j<00>s|j<00>s
<01><>t|j|	|
|<0C><00><02>

<00><>	ddd<04>
||=y#t$r}|<03>||<0B>

Yd}~<0B>
<01>d}~w
wxYw
#t$r}|<03>||<0B>

Yd}~<0B>
<01>,d}~w
wxYw
7<00><>#1s
w
Y

||=yxYw
<01>w
)ap
	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`).
	<09><03>	real_path<74>
first_path<EFBFBD>second_pathF<68>
<01>follow_symlinksN)rr<00>join<69>realpath<74>RecursionError<6F>scandir<69>name<6D>stat<61>OSError<6F>
is_symlinkr<00>	TreeEntryrT<00>is_file)
<0A>	root_full<6C>dir_rel<65>memorHrI<00>dir_full<6C>dir_real<61>	scan_iter<65>node_ent<6E>node_rel<65>
node_lstat<EFBFBD>
e<>	node_stats
             r!rTrT<00>s<>
<00><00><><00>4
<0F>G<EFBFBD>G<EFBFBD>L<EFBFBD>L<EFBFBD><19>G<EFBFBD>,<2C><18><0E>G<EFBFBD>G<EFBFBD><1C><1C>X<EFBFBD>&<26><18>
<0A>D<EFBFBD><18><1A>$<24>x<EFBFBD>.<2E><16><18>d<EFBFBD>8<EFBFBD>n<EFBFBD>RY<52>Z<>Z<><08>j<EFBFBD>j<EFBFBD><18><1A>!D
<01>i<EFBFBD><1B>D
<01>h<EFBFBD><10>g<EFBFBD>g<EFBFBD>l<EFBFBD>l<EFBFBD>7<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>2<>8<EFBFBD>
<0A><19><1D><1D>u<EFBFBD><1D>5<>J<EFBFBD><0F><19><19><1B><0E><19><1D><1D><1F>Y<EFBFBD><1B>I<EFBFBD><0E>o<EFBFBD>o<EFBFBD>l<EFBFBD>o<EFBFBD>3<><14>H<EFBFBD>M<EFBFBD>M<EFBFBD>8<EFBFBD>Z<EFBFBD><19>
C<EFBFBD>C<>&<26>y<EFBFBD>(<28>D<EFBFBD>(<28>L<EFBFBD>Y<>Y<>Y<><10><18><18><1A>h<EFBFBD>1<>1<>3<>
<13>H<EFBFBD>M<EFBFBD>M<EFBFBD>8<EFBFBD>Z<EFBFBD><19>
C<EFBFBD>C<>?D
<01>!D
<01>P

<EFBFBD>(<28>^<5E><>A
<12>
<0A><0F><1B>
<0A>a<EFBFBD>[<5B><0C><>
<0A><><13><0E><10><1C><0E>q<EFBFBD>k<EFBFBD>
<0A><><0E><>Z
<01><>;!D
<01>P

<EFBFBD>(<28>^<5E>s<EFBFBD><00>A0F:
<01>20F+<03>#E'<04>5F+<03>F<04>A
F+<03>
F)<08>%F+<03>>F+<03>F:
<01>'	F<07>0
F<07>:F+<03>F<07>F+<03>	F&<07>
F!<07>F+<03>!F&<07>&F+<03>+F7<07>0
F:
c#
<01><>K
<00>|
<01>t
|
<01>
std|
<01>d<03><03>
<00>
|<02>d}ttjj|<00>
di|
|<02>Ed
{<00><02><02>
y
7<00><05>w
)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*.
	NrOrPTrQ)rRrS<00>_iter_tree_files_nextrrrUrKs   r!rJrJM
sX<00><00><><00>2
<0A><18><18>(<28>!3<><11>I<EFBFBD>h<EFBFBD>\<5C>):<3A>;<3B><<3C><<3C><10><18><15>,<2C>!<21>"<22>'<27>'<27>/<2F>/<2F>$<24>"7<><12>R<EFBFBD><18><<3C>X<>
X<>
X<>rWc	#
<01>6K
<00>tjj||
<01>}tjj|<05>
}||v
r|
||<nt	||||
<01>
<01><00>
t
j
|<05>
5}|D]<5D>}tjj|
|j<00>}	|j|<04><02>
rt||	|||<04>Ed{<00><03><02>
<00>W|j<00>r|	<09><02>

<00>l|r
<01>o|j<00>s
<01><>|	<09><02>

<00><>	ddd<03>
||=y7<00>A#1s
w
Y

||=yxYw
<01>w
)am
	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 file path (:class:`str`).
	rYr]N)rrr_r`rarbrcrrurhrf)
rirjrkrHrIrlrmrnrorps
          r!ruruo
s<><00><00><><00>4
<0F>G<EFBFBD>G<EFBFBD>L<EFBFBD>L<EFBFBD><19>G<EFBFBD>,<2C><18><0E>G<EFBFBD>G<EFBFBD><1C><1C>X<EFBFBD>&<26><18>
<0A>D<EFBFBD><18><1A>$<24>x<EFBFBD>.<2E><16><18>d<EFBFBD>8<EFBFBD>n<EFBFBD>RY<52>Z<>Z<><08>j<EFBFBD>j<EFBFBD><18><1A><13>i<EFBFBD><1B><13>h<EFBFBD><10>g<EFBFBD>g<EFBFBD>l<EFBFBD>l<EFBFBD>7<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>2<>8<EFBFBD><0E>o<EFBFBD>o<EFBFBD>l<EFBFBD>o<EFBFBD>3<>%<25>Y<EFBFBD><08>$<24><08>,<2C>W<>W<>W<><10><18><18><1A>
<12>N<EFBFBD><18>X<EFBFBD>0<>0<>2<>
<12>N<EFBFBD><13><13>.
<EFBFBD>(<28>^<5E>X
<01><><13>.
<EFBFBD>(<28>^<5E>s=<00>A0D
<01>2AD
<03>
D<08>D
<03>$D
<03>5D
<03><D
<01>
D
<03>
D<07>
D
c

<01><00>t|S)
z<>
	Looks up 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`.
	)
r)
rcs
 r!<00>lookup_patternrx<00>
s<00><00>	<1D>T<EFBFBD>"<22>
"r#c
<01>n<00>d
}|D]-}|j<00>
<01>|j|
<01>
<00>
<01>"|j}<02>/|S)a&

	Matches the file to the patterns.

	*patterns* (:class:`~collections.abc.Iterable` of :class:`.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*<00>matchedr-s    r!r(r(<00>
sB<00><00><11><17><18><1D>W<EFBFBD><0C>_<EFBFBD>_<EFBFBD> <20>W<EFBFBD>%7<>%7<><04>%=<3D>%I<>
<14>_<EFBFBD>_<EFBFBD>7<EFBFBD><1D>	<10>r#z[pathspec.util.match_files() is deprecated. Use match_file() with a loop for better results.c
<01><><00>|D<00>cgc]}|j<00>
<01>|<02><02>}}t<00>}|
D] }t||<05>s
<01>|j|<05>

<00>"|Sc
c}w)
a<>

	.. version-deprecated:: 0.10.0
		This function is no longer used. Use the :func:`.match_file` function with a
		loop for better results.

	Matches the files to the patterns.

	*patterns* (:class:`~collections.abc.Iterable` of :class:`.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`).
	)r'<00>setr(<00>add)r)r7rA<00>use_patternsr:r*s      r!<00>match_filesr<00>
s\<00><00>.%-<2D>J<>5<EFBFBD><05>
<0A>
<0A>0I<30><15>J<><1C>J<><13><05><1C>
<12><1A>T<EFBFBD><0F><0C>d<EFBFBD>#<23><0F><13><13>D<EFBFBD><19><1A>	<15>
<14><>K
s
<00>A<04>Ac
<01><><00>|
<01>t}
|
<01>J|
<01><00>
tj|<00>
}|
D]"}|j|tj
<00>}<02>$|j
d<02>
r|dd
}|S|j
d<04>
r|dd
}|S)a<>
	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
	: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 ``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`).
	N<>
/rz./<2F>)<07>NORMALIZE_PATH_SEPSr<00>fspath<74>replace<63>	posixpathr<00>
startswith)r*<00>
separators<EFBFBD>	norm_filers    r!<00>normalize_filer<65><00>
s<><00><00>(<0F><16>"<22>*<2A><12><1E>
*<2A>
<EFBFBD>
*<2A><1E><15>)<29>)<29>D<EFBFBD>/<2F><19><16>
4<>S<EFBFBD><17><1F><1F><03>Y<EFBFBD>]<5D>]<5D>3<>)<29>
4<><0E><18><18><13><1D><17>
<01><02>m<EFBFBD>)<29>	<12>
<11>	<10><1A><1A>4<EFBFBD> <20><17>
<01><02>m<EFBFBD>)<29><11>
r#zcpathspec.util.normalize_files() is deprecated. Use normalize_file() with a loop for better results.c
<01>p<00>i}|D].}t
||
<01>
<01>}||vr||j|<03>

<00>)|g
||<<00>0|S)a<>
	.. version-deprecated:: 0.10.0
		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`).
	)
r<>)r<>r5)r7r<><00>
norm_filesrr<>s     r!<00>normalize_filesr<73>sS<00><00>4)+<2B><1A>
<12>"<22>T<EFBFBD><1C>T<EFBFBD>j<EFBFBD>9<>)<29><0E>*<2A><1C>
<0A>i<EFBFBD><18><1F><1F><04>%<25> <20>6<EFBFBD>:<3A>i<EFBFBD><18>"<22>	<13>
r#c
<01><><00>t
|t<00>std
|<00>d<02><03>
<00>
t|
<01>
std|
<01>d<04><03>
<00>
|tvr|st|t|<00><00>
|
t|<y)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=rPN)r2rrSrRr<00>AlreadyRegisteredError)rc<00>pattern_factory<72>overrides   r!<00>register_patternr<6E>=sk<00><00>&	<13>4<EFBFBD><13><1D><11>U<EFBFBD>T<EFBFBD>I<EFBFBD>.<2E>/<2F>0<>0<><10><1F>!<21><11>%<25>_<EFBFBD>(<28>(9<>:<3A>;<3B>;<3B><08> <20> <20><18><1E>t<EFBFBD>%9<>$<24>%?<3F>@<40>@<40>-<2D>
<15>d<EFBFBD>
r#c
<01>f<00><00>eZ
dZd
Z						d<06>f
d<02>Zedd<03><04>Zedd<04><04>Zedd<05><04>Z<08>x
Z	S)	r<>z|
	The :exc:`AlreadyRegisteredError` exception is raised when a pattern factory
	is registered under a name already in use.
	c
<01>&<00>
<01>t<00>|<00>|
|<02>
y
)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<><02>super<65>__init__)<04>selfrcr<><00>	__class__s   <20>r!r<>zAlreadyRegisteredError.__init__bs<00><><00><08>'<27><12>4<EFBFBD><1F>)r#c

<01>:<00>|j<00>d
|j<00>d<02>S)<03>4
		*message* (:class:`str`) is the error message.
		z+ is already registered for pattern factory=<3D>
.)rcr<><00>
r<>s
 r!<00>messagezAlreadyRegisteredError.messageqs(<00><00><0B>i<EFBFBD>i<EFBFBD>]<5D>=<3D>
<EFBFBD><1A><1A><1D>Q<EFBFBD>
 <20>r#c

<01> <00>|jd
S)zB
		*name* (:class:`str`) is the name of the registered pattern.
		r<00>
<01>argsr<73>s
 r!rczAlreadyRegisteredError.name{s<00><00>

<0E><19><19>1<EFBFBD><1C>r#c

<01> <00>|jd
S)za
		*pattern_factory* (:class:`~collections.abc.Callable`) is the registered
		pattern factory.
		rr<>r<>s
 r!r<>z&AlreadyRegisteredError.pattern_factory<72><00><00><00>
<0E><19><19>1<EFBFBD><1C>r#)rcrr<><00>&Callable[[Union[str, bytes]], Pattern]<5D>return<72>None<6E>r<>r)r<>r<>)
<EFBFBD>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__r<5F><00>propertyr<79>rcr<><00>
__classcell__<5F>
r<>s
@r!r<>r<>\se<00><><00><05>

*<2A><0B>
*<2A>:<3A>
*<2A><0B>	
*<2A><0B><04><0B><04><0B><16><0B><16><0B><16><0B>r#r<>c
<01>|<00><00>eZ
dZd
Z								d<07>f
d<02>Zedd<03><04>Zedd<04><04>Zedd<05><04>Zedd<06><04>Z	<09>x
Z
S)	razM
	The :exc:`RecursionError` exception is raised when recursion is detected.
	c
<01>(<00>
<01>t<00>|<00>|
||<03>
y
)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*.
		Nr<4E>)r<>rZr[r\r<>s    <20>r!r<>zRecursionError.__init__<5F>s<00><><00> <08>'<27><12>9<EFBFBD>j<EFBFBD>+<2B>6r#c

<01> <00>|jd
S)zx
		*first_path* (:class:`str`) is the first path encountered for
		:attr:`self.real_path <RecursionError.real_path>`.
		rr<>r<>s
 r!r[zRecursionError.first_path<74>r<>r#c

<01>V<00>d
|j<00>d|j<00>d|j<00>d<04>S)r<>z
Real path z was encountered at z
 and then r<>rYr<>s
 r!r<>zRecursionError.message<67>s:<00><00><10><04><0E><0E>!<21>!5<>d<EFBFBD>o<EFBFBD>o<EFBFBD>5H<35>
I
<0F><13><1F><1F>"<22>!<21>
%<25>r#c

<01> <00>|jd
S)zV
		*real_path* (:class:`str`) is the real path that recursion was
		encountered on.
		rr<>r<>s
 r!rZzRecursionError.real_path<74>r<>r#c

<01> <00>|jd
S)zz
		*second_path* (:class:`str`) is the second path encountered for
		:attr:`self.real_path <RecursionError.real_path>`.
		r<>r<>r<>s
 r!r\zRecursionError.second_path<74>r<>r#)rZrr[rr\rr<>r<>r<>)r<>r<>r<>r<>r<>r<>r[r<>rZr\r<>r<>s
@r!rara<00>s<><00><><00><05>7<>
<10>7<><12>7<><13>	7<>
<0B>7<>$<0B><16><0B><16><0B><04><0B><04><0B><16><0B><16><0B><16><0B>r#ra)
<01>frozenc
<01>8<00>eZ
dZUd
ZdZded<	ded<	ded<y	)
<EFBFBD>CheckResultze
	The :class:`CheckResult` class contains information about the file and which
	pattern matched it.
	)r*r'r,rr*<00>Optional[bool]r'z
Optional[int]r,N)r<>r<>r<>r<><00>	__slots__<5F>__annotations__<5F>r#r!r<>r<><00>s4<00><00><05><03><19><10><1E><05><19>
<18><05>
	<16>
<15>r#r<>c
<01><00>eZ
dZd
ZdZdd<03>Zy)r6z>
	The :class:`.MatchDetail` class contains information about
	<09>
r)c
<01><00>|
|_y
)z<>
		Initialize the :class:`.MatchDetail` instance.

		*patterns* (:class:`~collections.abc.Sequence` of :class:`.Pattern`)
		contains the patterns that matched the file in the order they were encountered.
		Nr<4E>)r<>r)s  r!r<>zMatchDetail.__init__<5F>s<00><00><1B>$<24>-<2D>r#N)r)zSequence[Pattern]r<>r<>)r<>r<>r<>r<>r<>r<>r<>r#r!r6r6<00>s<00><00><05>
<1B><19>
r#r6c
<01>V<00>eZ
dZd
ZdZ										d	d<03>Zd
dd<05>Zd
dd<06>Zdd<07>Zd
d
d<08>Z	y)rgzP
	The :class:`TreeEntry` class contains information about a file-system entry.
	<09><04>_lstatrcr<00>_statc
<01>B<00>||_	|
|_
	||_	||_y
)aM

		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<4E>)r<>rcr<00>lstatrds     r!r<>zTreeEntry.__init__s:<00><00>(!&<26>$<24>+<2B><06><18>$<24>)<29><06><18>$<24>)<29><06> $<24>$<24>*<2A>r#Nc
<01>|<00>|
<01>d
}
|
r|jn|j}tj|j<00>
S)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`).
		T)r<>r<>rd<00>S_ISDIR<49>st_mode<64>r<>rIrss   r!rzTreeEntry.is_dir-<00>5<00><00><12><19><16><<3C>(<28>d<EFBFBD>j<EFBFBD>j<EFBFBD>d<EFBFBD>k<EFBFBD>k<EFBFBD>)<29>	
<0A><1C><1C>i<EFBFBD>'<27>'<27>	(<28>(r#c
<01>|<00>|
<01>d
}
|
r|jn|j}tj|j<00>
S)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`).
		T)r<>r<>rd<00>S_ISREGr<47>r<>s   r!rhzTreeEntry.is_file=r<>r#c

<01>T<00>t
j|jj<00>
S)
zC
		Returns whether the entry is a symbolic link (:class:`bool`).
		)rd<00>S_ISLNKr<4B>r<>r<>s
 r!rfzTreeEntry.is_symlinkMs<00><00>
<0E><1C><1C>d<EFBFBD>k<EFBFBD>k<EFBFBD>)<29>)<29>	*<2A>*r#c

<01>><00>|
<01>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`).
		T)r<>r<>)r<>rIs  r!rdzTreeEntry.statSs$<00><00><12><19><16><<3C>#<23><14><1A><1A>4<><14><1B><1B>4r#)
rcrrrr<><00>os.stat_resultrdr<>r<>r<><00>
N)rIr<>r<><00>bool)r<>r<>)rIr<>r<>r<>)
r<EFBFBD>r<>r<>r<>r<>r<>rrhrfrdr<>r#r!rgrg<00>sX<00><00><05>
1<><19>&<06><0B>&<06>	<0C>&<06>
<18>	&<06>
	<17>&<06><0B>
&<06>P
)<29> )<29> +<2B>
5r#rg)rzpathlib.Pathr<68>rr<>)r)zIterable[tuple[int, Pattern]]r*rr+r<>r<>z$tuple[Optional[bool], Optional[int]])r)<00>Iterable[Pattern]r7<00>
Iterable[str]r8r<>r<>zdict[str, MatchDetail])r)r<>r<>zlist[tuple[int, Pattern]])rEr	r<>r<>r%)rL<00>StrPathrH<00>#Optional[Callable[[OSError], None]]rIr<>r<><00>Iterator['TreeEntry'])rirrjrrk<00>dict[str, str]rHr<>rIr<>r<>r<>)rLr<>rHr<>rIr<>r<><00>
Iterator[str])rirrjrrkr<>rHr<>rIr<>r<>r<>)rcrr<>zCallable[[AnyStr], Pattern])r)r<>r*rr<>r<>)r)r<>r7r<>r<>zset[str])r*r<>r<><00>Optional[Collection[str]]r<>r)r7zIterable[StrPath]r<>r<>r<>zdict[str, list[StrPath]])rcrr<>z<Union[Callable[[Union[str, bytes]], Pattern], type[Pattern]]r<>r<>r<>r<>)>r<><00>
__future__rr<00>os.path<74>pathlibr<62>rd<00>collections.abcrrrr<00>dataclassesr<00>typingr	r
rrr
rrr-r<00>_typingrrr<00>PathLiker<65>rrrr<00>altsepr<70>rr<>r"r0r=rBrFrMrVrTrJrurxr(rr<>r<>r<><00>	Exceptionr<6E>rar<><00>objectr6rg)
<01>__seps
0r!<00><module>r<>
s<><00>


<01>
<04>
#<23>	<09><0E><0E><10><0B>
<0B>
<0B>


<0C>
<07>
<07>
<07>


<EFBFBD>

<0A><10><03>R<EFBFBD>[<5B>[<5B><13>%<25>%<25>
&<26><07><12>:<3A>W<EFBFBD>-<2D><08>
<04>
<16>m<EFBFBD>7<EFBFBD>d<EFBFBD>C<><0B>
<04>
<13>:<3A>W<EFBFBD>-<2D><08>
<04><12>v<EFBFBD>v<EFBFBD>r<EFBFBD>y<EFBFBD>y<EFBFBD>!<21><02>
<EFBFBD>	<09>e<EFBFBD>y<EFBFBD>}<7D>}<7D>$<24><06>c<EFBFBD>5<EFBFBD>
<11><02><13>

<04>K
M
<01><14>G<>L<>
<04>
<11>( $<24>)
 <20>(<28>)
 <20>
<EFBFBD>)
 <20><1D>)
 <20>*<2A>	)
 <20>^
 $<24>,
<15><1C>,
<15><15>,
<15><1D>,
<15><1C>	,
<15>^

<03><1C>
<03><1E>
<03>(
L
<01><0C>
J<><03>
L
<01><03>
L
<01>26<32> $<24>
[
<01><0E>
[
<01>.<2E>
[
<01><1E>
[
<01><1B>	
[
<01>B
L

<14><0F>L

<14>

<0A>L

<14><16>L

<14>/<2F>	L

<14>
<14>L

<14><1B>
L

<14>b26<32> $<24>
Y
<01><0E>
Y
<01>.<2E>
Y
<01><1E>
Y
<01><13>	
Y
<01>D
;
<14><0F>;
<14>

<0A>;
<14><16>;
<14>/<2F>	;
<14>
<14>;
<14><13>
;
<14>|
	
#<23>
<10>(<0C>
<13><03>
<15><1C>
<15><15>
<15><0E>
<15>	<03>
<15>>*.<2E>'
<12><0E>'
<12>
&<26>'
<12>	<09>'
<12>T
<0C>
<1C><03>*.<2E>
<13><19>
<13>
&<26>
<13><1E>
<13>	<03>
<13>H
!<21>
.<2E>
<EFBFBD>
.<2E>N<>
.<2E><1A>
.<2E>
<EFBFBD>	
.<2E>>,
<16>Y<EFBFBD>,
<16>^
7
<16>Y<EFBFBD>7
<16>t
<0B>$<24>
<17>
<05>'<27>(<28>#<23>
<05><18>
<05>>
<06>&<26>
<06>0c

5<><06>c

5<><35>Ss<00> !G