
    Ae                         d Z ddlZddlZddlZddlmZmZmZmZm	Z
mZmZmZmZ  G d de      Z G d de      Z ej$                          G d d	e             Zy)
z8
This module provides the base definition for patterns.
    N)	AnyAnyStrIterableIteratorMatchOptionalPatternTupleUnionc                   \    e Zd ZdZdZdee   ddfdZdee	   de
e	   fdZd	e	dee   fd
Zy)r	   zG
	The :class:`Pattern` class is the abstract definition of a pattern.
	includer   returnNc                     || _         y)z
		Initializes the :class:`Pattern` instance.

		*include* (:class:`bool` or :data:`None`) is whether the matched
		files should be included (:data:`True`), excluded (:data:`False`),
		or is a null-operation (:data:`None`).
		Nr   )selfr   s     0lib/python3.12/site-packages/pathspec/pattern.py__init__zPattern.__init__   s     $,    filesc              #      K   t        j                  dj                  | j                        t        d       |D ]  }| j                  |      |  yw)a  
		DEPRECATED: This method is no longer used and has been replaced by
		:meth:`.match_file`. Use the :meth:`.match_file` method with a loop
		for similar results.

		Matches this pattern against the specified files.

		*files* (:class:`~collections.abc.Iterable` of :class:`str`)
		contains each file relative to the root directory (e.g.,
		:data:`"relative/path/to/file"`).

		Returns an :class:`~collections.abc.Iterable` yielding each matched
		file path (:class:`str`).
		z{0.__module__}.{0.__qualname__}.match() is deprecated. Use {0.__module__}.{0.__qualname__}.match_file() with a loop for similar results.   )
stacklevelN)warningswarnformat	__class__DeprecationWarning
match_file)r   r   files      r   matchzPattern.match,   sS      -- F4>>.1	>  d
ood'
Js   AAAr   c                 J    t        dj                  | j                              )z
		Matches this pattern against the specified file.

		*file* (:class:`str`) is the normalized file path to match against.

		Returns the match result if *file* matched; otherwise, :data:`None`.
		z;{0.__module__}.{0.__qualname__} must override match_file().)NotImplementedErrorr   r   )r   r   s     r   r   zPattern.match_fileE   s"     	@
F4>>	 r   )__name__
__module____qualname____doc__	__slots__r   boolr   r   strr   r    r   r    r   r   r	   r	      sW    
 Xd^    (3- 2
C 
HSM 
r   r	   c                        e Zd ZdZdZ	 ddeeef   dee	   ddf fdZ
dd de	fd	Zd
eded   fdZededeee	f   fd       Z xZS )RegexPatternza
	The :class:`RegexPattern` class is an implementation of a pattern
	using regular expressions.
	)regexNpatternr   r   c                 |   t        |t        t        f      rE|J dj                  ||             | j	                  |      \  }}|\t        j                  |      }nF|t        |d      r|}n5||1J dj                  ||             t        dj                  |            t        t        | /  |       | _        y)a0  
		Initializes the :class:`RegexPattern` instance.

		*pattern* (:class:`str`, :class:`bytes`, :class:`re.Pattern`, or
		:data:`None`) is the pattern to compile into a regular expression.

		*include* (:class:`bool` or :data:`None`) must be :data:`None`
		unless *pattern* is a precompiled regular expression (:class:`re.Pattern`)
		in which case it is whether matched files should be included
		(:data:`True`), excluded (:data:`False`), or is a null operation
		(:data:`None`).

			.. NOTE:: Subclasses do not need to support the *include*
			   parameter.
		Nz8include:{!r} must be null when pattern:{!r} is a string.r    z4include:{!r} must be null when pattern:{!r} is null.z2pattern:{!r} is not a string, re.Pattern, or None.)
isinstancer)   bytesr   pattern_to_regexrecompilehasattr	TypeErrorsuperr,   r   r-   )r   r.   r   r-   r   s       r   r   zRegexPattern.__init__[   s    * #u&
/ >VGW ))'2>5' JJuEww8 5 / :VGW
 
GNNwW	XXd$W-!$*r   otherc                     t        |t              r4| j                  |j                  k(  xr | j                  |j                  k(  S t        S )z
		Tests the equality of this regex pattern with *other* (:class:`RegexPattern`)
		by comparing their :attr:`~Pattern.include` and :attr:`~RegexPattern.regex`
		attributes.
		)r0   r,   r   r-   NotImplemented)r   r8   s     r   __eq__zRegexPattern.__eq__   s9     |$
,,%--
'
EDJJ%++,EE
r   r   RegexMatchResultc                 l    | j                   (| j                  j                  |      }|t        |      S y)a
  
		Matches this pattern against the specified file.

		*file* (:class:`str`)
		contains each file relative to the root directory (e.g., "relative/path/to/file").

		Returns the match result (:class:`RegexMatchResult`) if *file*
		matched; otherwise, :data:`None`.
		N)r   r-   r    r<   )r   r   r    s      r   r   zRegexPattern.match_file   s6     
\\::D!5E""	r   c                 
    |dfS )a  
		Convert the pattern into an uncompiled regular expression.

		*pattern* (:class:`str`) is the pattern to convert into a regular
		expression.

		Returns the uncompiled regular expression (:class:`str` or :data:`None`),
		and whether matched files should be included (:data:`True`),
		excluded (:data:`False`), or is a null-operation (:data:`None`).

			.. NOTE:: The default implementation simply returns *pattern* and
			   :data:`True`.
		Tr*   )clsr.   s     r   r2   zRegexPattern.pattern_to_regex   s     
$r   )N)r#   r$   r%   r&   r'   r   r   PatternHintr   r(   r   r;   r)   r   classmethodr
   r2   __classcell__)r   s   @r   r,   r,   R   s     
 !4$%4 D>4 	4l	 	D 	C H-?$@ " C E#t),<  r   r,   c                        e Zd ZU dZdZeed<   y)r<   zq
	The :class:`RegexMatchResult` data class is used to return information
	about the matched regular expression.
	)r    r    N)r#   r$   r%   r&   r'   	MatchHint__annotations__r*   r   r   r<   r<      s     	r   r<   )r&   dataclassesr3   r   typingr   r   r   r   r   rD   r   r	   r@   r
   r   objectr,   	dataclassr<   r*   r   r   <module>rJ      sf     	 	 	 	;f ;|j7 jZ v  r   