o
    yAf~                     @   s   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 deZG dd deZe G dd	 d	eZdS )
z8
This module provides the base definition for patterns.
    N)	AnyAnyStrIterableIteratorMatchOptionalPatternTupleUnionc                   @   sZ   e Zd ZdZdZdee ddfddZdee	 de
e	 fd	d
Zde	dee fddZdS )r   zG
	The :class:`Pattern` class is the abstract definition of a pattern.
	includer   returnNc                 C   s
   || _ dS )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    r   5/usr/lib/python3.10/site-packages/pathspec/pattern.py__init__   s   	zPattern.__init__filesc                 c   s>    t jdj| jdtdd |D ]}| |dur|V  qdS )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., ``"relative/path/to/file"``).

		Returns an :class:`~collections.abc.Iterable` yielding each matched file
		path (:class:`str`).
		z{cls.__module__}.{cls.__qualname__}.match() is deprecated. Use {cls.__module__}.{cls.__qualname__}.match_file() with a loop for similar results.cls   )
stacklevelN)warningswarnformat	__class__DeprecationWarning
match_file)r   r   filer   r   r   match.   s   zPattern.matchr   c                 C   s   t dj| jd)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?{cls.__module__}.{cls.__qualname__} must override match_file().r   )NotImplementedErrorr   r   )r   r   r   r   r   r   F   s   zPattern.match_file)__name__
__module____qualname____doc__	__slots__r   boolr   r   strr   r   r   r   r   r   r   r   r      s    r   c                       s   e Zd ZdZdZ	ddeeedf dee	 ddf fddZ
d	d de	fd
dZdeded fddZededeee	f fddZ  ZS )RegexPatternza
	The :class:`RegexPattern` class is an implementation of a pattern using
	regular expressions.
	)patternregexNr(   r   r   c                    s   t |ttfr'|du sJ d|d|d| |\}}|dur&t|}n(|dur3t|dr3|}n|du rG|du sFJ d|d|dntd|dtt	| 
| || _	 || _dS )	a(  
		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.
		Nzinclude:z must be null when pattern:z is a string.r   z	 is null.zpattern:z& is not a string, re.Pattern, or None.)
isinstancer&   bytespattern_to_regexrecompilehasattr	TypeErrorsuperr'   r   r(   r)   )r   r(   r   r)   r   r   r   r   _   s(   


zRegexPattern.__init__otherc                 C   s&   t |tr| j|jko| 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.
		)r*   r'   r   r)   NotImplemented)r   r3   r   r   r   __eq__   s   
zRegexPattern.__eq__r   RegexMatchResultc                 C   s*   | j dur| j|}|durt|S dS )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   r6   )r   r   r   r   r   r   r      s
   

zRegexPattern.match_filec                 C   s   |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   )r   r(   r   r   r   r,      s   zRegexPattern.pattern_to_regex)N)r    r!   r"   r#   r$   r
   r   PatternHintr   r%   r   r5   r&   r   classmethodr	   r,   __classcell__r   r   r2   r   r'   S   s    9$r'   c                   @   s   e Zd ZU dZdZeed< dS )r6   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   r6      s
   
 r6   )r#   dataclassesr-   r   typingr   r   r   r   r   r:   r   r   r7   r	   r
   objectr'   	dataclassr6   r   r   r   r   <module>   s    ,?s