U
    -WjNN  ã                   @   s´  d Z ddlZddlZddlmZ ddlmZ ddlmZmZ ddl	m
Z
mZmZmZ ddlmZ dd	lmZ d
ddddddddddddddddddgZdd„ Zdd„ Zedd„ ƒZed d!d!d"�G d#d$„ d$ƒƒZd%d„ Zed d!d!d&�G d'd(„ d(ƒƒZdPd)d„Zed d!d!d"�G d*d+„ d+ƒƒZd,d„ Zed d!d!d"�G d-d.„ d.ƒƒZd/d„ Zed d d!d"�G d0d1„ d1ƒƒZd2d„ Zed d!d!d"�G d3d4„ d4ƒƒZ dQd5d„Z!ed d!d!d"�G d6d7„ d7ƒƒZ"dRd8d„Z#ed d!d!d&�G d9d:„ d:ƒƒZ$d;d„ Z%d<d„ Z&d=d„ Z'd>d„ Z(ed d!d!d&�G d?d@„ d@ƒƒZ)dAd„ Z*ed d!d!d&�G dBdC„ dCƒƒZ+dDd„ Z,ed d!d!d"�G dEdF„ dFƒƒZ-dGdH„ Z.ed d!d!d"�G dIdJ„ dJƒƒZ/de0e1fdKœdLd„Z2ed d!d!d"�G dMdN„ dNƒƒZ3dOd„ Z4dS )Sz
Commonly useful validators.
é    N)Úcontextmanager)ÚPatterné   )Úget_run_validatorsÚset_run_validators)Ú_AndValidatorÚand_ÚattribÚattrs)Údefault_if_none)ÚNotCallableErrorr   Údeep_iterableÚdeep_mappingÚdisabledÚgeÚget_disabledÚgtÚin_Úinstance_ofÚis_callableÚleÚltÚ
matches_reÚmax_lenÚmin_lenÚnot_ÚoptionalÚor_Úset_disabledc                 C   s   t |  ƒ dS )a  
    Globally disable or enable running validators.

    By default, they are run.

    Args:
        disabled (bool): If `True`, disable running all validators.

    .. warning::

        This function is not thread-safe!

    .. versionadded:: 21.3.0
    N©r   )r   © r    úZc:\users\psant\downloads\hotstarbackend\school\venv38\Lib\site-packages\attr/validators.pyr   *   s    c                   C   s   t ƒ  S )zº
    Return a bool indicating whether validators are currently disabled or not.

    Returns:
        bool:`True` if validators are currently disabled.

    .. versionadded:: 21.3.0
    )r   r    r    r    r!   r   <   s    	c                   c   s"   t dƒ z
dV  W 5 t dƒ X dS )z°
    Context manager that disables running validators within its context.

    .. warning::

        This context manager is not thread-safe!

    .. versionadded:: 21.3.0
    FTNr   r    r    r    r!   r   H   s    
FT)ÚreprÚslotsZunsafe_hashc                   @   s"   e Zd Zeƒ Zdd„ Zdd„ ZdS )Ú_InstanceOfValidatorc              	   C   sD   t || jƒs@d|j› d| j›d|›d|j›d�	}t||| j|ƒ‚dS )úP
        We use a callable class to be able to change the ``__repr__``.
        ú'ú
' must be ú (got z that is a ú).N)Ú
isinstanceÚtypeÚnameÚ	__class__Ú	TypeError©ÚselfÚinstÚattrÚvalueÚmsgr    r    r!   Ú__call__^   s    $üz_InstanceOfValidator.__call__c                 C   s   d| j ›d�S )Nz <instance_of validator for type ú>©r+   ©r0   r    r    r!   Ú__repr__k   s    z_InstanceOfValidator.__repr__N©Ú__name__Ú
__module__Ú__qualname__r	   r+   r5   r9   r    r    r    r!   r$   Z   s   r$   c                 C   s   t | ƒS )aØ  
    A validator that raises a `TypeError` if the initializer is called with a
    wrong type for this particular attribute (checks are performed using
    `isinstance` therefore it's also valid to pass a tuple of types).

    Args:
        type (type | tuple[type]): The type to check for.

    Raises:
        TypeError:
            With a human readable error message, the attribute (of type
            `attrs.Attribute`), the expected type, and the value it got.
    )r$   r7   r    r    r!   r   o   s    )r"   Úfrozenr#   c                   @   s(   e Zd Zeƒ Zeƒ Zdd„ Zdd„ ZdS )Ú_MatchesReValidatorc                 C   s<   |   |¡s8d|j› d| jj›d|›d�}t||| j|ƒ‚dS )r%   r&   z' must match regex z (z	 doesn't)N)Ú
match_funcr,   ÚpatternÚ
ValueErrorr/   r    r    r!   r5   …   s    
üz_MatchesReValidator.__call__c                 C   s   d| j ›d�S )Nz"<matches_re validator for pattern r6   )rA   r8   r    r    r!   r9   ’   s    z_MatchesReValidator.__repr__N)r;   r<   r=   r	   rA   r@   r5   r9   r    r    r    r!   r?   €   s   r?   c                 C   s¤   t jdt jt jf}||krDd d tdd„ t|ƒD ƒƒ¡¡}t|ƒ‚t	| t
ƒrd|r^d}t|ƒ‚| }nt  | |¡}|t jkr‚|j}n|t jkr”|j}n|j}t||ƒS )aâ  
    A validator that raises `ValueError` if the initializer is called with a
    string that doesn't match *regex*.

    Args:
        regex (str, re.Pattern):
            A regex string or precompiled pattern to match against

        flags (int):
            Flags that will be passed to the underlying re function (default 0)

        func (typing.Callable):
            Which underlying `re` function to call. Valid options are
            `re.fullmatch`, `re.search`, and `re.match`; the default `None`
            means `re.fullmatch`. For performance reasons, the pattern is
            always precompiled using `re.compile`.

    .. versionadded:: 19.2.0
    .. versionchanged:: 21.3.0 *regex* can be a pre-compiled pattern.
    Nz'func' must be one of {}.z, c                 s   s   | ]}|r|j pd V  qdS )ÚNoneN)r;   )Ú.0Úer    r    r!   Ú	<genexpr>¯   s     zmatches_re.<locals>.<genexpr>zR'flags' can only be used with a string pattern; pass flags to re.compile() instead)ÚreÚ	fullmatchÚsearchÚmatchÚformatÚjoinÚsortedÚsetrB   r*   r   r.   Úcompiler?   )ÚregexÚflagsÚfuncZvalid_funcsr4   rA   r@   r    r    r!   r   –   s(    ÿÿ


c                   @   s"   e Zd Zeƒ Zdd„ Zdd„ ZdS )Ú_OptionalValidatorc                 C   s   |d krd S |   |||¡ d S )N©Ú	validator©r0   r1   r2   r3   r    r    r!   r5   Ê   s    z_OptionalValidator.__call__c                 C   s   d| j ›d�S )Nz<optional validator for z	 or None>rT   r8   r    r    r!   r9   Ð   s    z_OptionalValidator.__repr__N)r;   r<   r=   r	   rU   r5   r9   r    r    r    r!   rS   Æ   s   rS   c                 C   s"   t | ttfƒrtt| ƒƒS t| ƒS )a&  
    A validator that makes an attribute optional.  An optional attribute is one
    which can be set to `None` in addition to satisfying the requirements of
    the sub-validator.

    Args:
        validator
            (typing.Callable | tuple[typing.Callable] | list[typing.Callable]):
            A validator (or validators) that is used for non-`None` values.

    .. versionadded:: 15.1.0
    .. versionchanged:: 17.1.0 *validator* can be a list of validators.
    .. versionchanged:: 23.1.0 *validator* can also be a tuple of validators.
    )r*   ÚlistÚtuplerS   r   rT   r    r    r!   r   Ô   s    c                   @   s,   e Zd Zeƒ Zedd�Zdd„ Zdd„ ZdS )Ú_InValidatorF)Úhashc                 C   s\   z|| j k}W n tk
r&   d}Y nX |sXd|j› d| j›d|›d�}t||| j|ƒ‚d S )NFr&   z' must be in r(   ú))Úoptionsr.   r,   Ú_original_optionsrB   )r0   r1   r2   r3   Z
in_optionsr4   r    r    r!   r5   î   s    
üz_InValidator.__call__c                 C   s   d| j ›d�S )Nz<in_ validator with options r6   )r]   r8   r    r    r!   r9   ý   s    z_InValidator.__repr__N)r;   r<   r=   r	   r\   r]   r5   r9   r    r    r    r!   rY   é   s   
rY   c                 C   s&   | }t | tttfƒrt| ƒ} t| |ƒS )aÖ  
    A validator that raises a `ValueError` if the initializer is called with a
    value that does not belong in the *options* provided.

    The check is performed using ``value in options``, so *options* has to
    support that operation.

    To keep the validator hashable, dicts, lists, and sets are transparently
    transformed into a `tuple`.

    Args:
        options: Allowed options.

    Raises:
        ValueError:
            With a human readable error message, the attribute (of type
            `attrs.Attribute`), the expected options, and the value it got.

    .. versionadded:: 17.1.0
    .. versionchanged:: 22.1.0
       The ValueError was incomplete until now and only contained the human
       readable error message. Now it contains all the information that has
       been promised since 17.1.0.
    .. versionchanged:: 24.1.0
       *options* that are a list, dict, or a set are now transformed into a
       tuple to keep the validator hashable.
    )r*   rW   ÚdictrN   rX   rY   )r\   Zrepr_optionsr    r    r!   r     s    c                   @   s   e Zd Zdd„ Zdd„ ZdS )Ú_IsCallableValidatorc                 C   s,   t |ƒs(d}t|j|j||jd�|d�‚dS )r%   z?'{name}' must be callable (got {value!r} that is a {actual!r}).)r,   r3   Úactual)r4   r3   N)Úcallabler   rK   r,   r-   )r0   r1   r2   r3   Úmessager    r    r!   r5   &  s    ÿ  ÿüz_IsCallableValidator.__call__c                 C   s   dS )Nz<is_callable validator>r    r8   r    r    r!   r9   6  s    z_IsCallableValidator.__repr__N)r;   r<   r=   r5   r9   r    r    r    r!   r_   $  s   r_   c                   C   s   t ƒ S )aˆ  
    A validator that raises a `attrs.exceptions.NotCallableError` if the
    initializer is called with a value for this particular attribute that is
    not callable.

    .. versionadded:: 19.1.0

    Raises:
        attrs.exceptions.NotCallableError:
            With a human readable error message containing the attribute
            (`attrs.Attribute`) name, and the value it got.
    )r_   r    r    r    r!   r   :  s    c                   @   s:   e Zd Zeeƒ d�Zedeeƒ ƒd�Zdd„ Zdd„ Z	dS )Ú_DeepIterablerT   N©ÚdefaultrU   c                 C   s4   | j dk	r|   |||¡ |D ]}|  |||¡ qdS ©r%   N©Úiterable_validatorÚmember_validator)r0   r1   r2   r3   Úmemberr    r    r!   r5   Q  s    
z_DeepIterable.__call__c                 C   s.   | j d krdn
d| j ›�}d|› d| j›d�S )NÚ ú z<deep_iterable validator forz iterables of r6   rg   )r0   Ziterable_identifierr    r    r!   r9   [  s    ÿ
ýÿz_DeepIterable.__repr__)
r;   r<   r=   r	   r   ri   r   rh   r5   r9   r    r    r    r!   rc   J  s    ÿ
rc   c                 C   s    t | ttfƒrt| Ž } t| |ƒS )aC  
    A validator that performs deep validation of an iterable.

    Args:
        member_validator: Validator to apply to iterable members.

        iterable_validator:
            Validator to apply to iterable itself (optional).

    Raises
        TypeError: if any sub-validators fail

    .. versionadded:: 19.1.0
    )r*   rW   rX   r   rc   ©ri   rh   r    r    r!   r   g  s    c                   @   sF   e Zd Zeeƒ d�Zeeƒ d�Zedeeƒ ƒd�Zdd„ Z	dd„ Z
dS )Ú_DeepMappingrT   Nrd   c                 C   sF   | j dk	r|   |||¡ |D ]$}|  |||¡ |  |||| ¡ qdS rf   )Úmapping_validatorÚkey_validatorÚvalue_validator)r0   r1   r2   r3   Úkeyr    r    r!   r5   �  s
    
z_DeepMapping.__call__c                 C   s   d| j ›d| j›d�S )Nz,<deep_mapping validator for objects mapping z to r6   )rp   rq   r8   r    r    r!   r9   Œ  s    z_DeepMapping.__repr__)r;   r<   r=   r	   r   rp   rq   r   ro   r5   r9   r    r    r    r!   rn   {  s
   rn   c                 C   s   t | ||ƒS )a�  
    A validator that performs deep validation of a dictionary.

    Args:
        key_validator: Validator to apply to dictionary keys.

        value_validator: Validator to apply to dictionary values.

        mapping_validator:
            Validator to apply to top-level mapping attribute (optional).

    .. versionadded:: 19.1.0

    Raises:
        TypeError: if any sub-validators fail
    )rn   )rp   rq   ro   r    r    r!   r   �  s    c                   @   s.   e Zd Zeƒ Zeƒ Zeƒ Zdd„ Zdd„ ZdS )Ú_NumberValidatorc                 C   s<   |   || j¡s8d|j› d| j› d| j› d|› �}t|ƒ‚dS )r%   r&   r'   rl   ú: N)Úcompare_funcÚboundr,   Ú
compare_oprB   r/   r    r    r!   r5   ª  s    "z_NumberValidator.__call__c                 C   s   d| j › d| j› d�S )Nz<Validator for x rl   r6   )rw   rv   r8   r    r    r!   r9   ²  s    z_NumberValidator.__repr__N)	r;   r<   r=   r	   rv   rw   ru   r5   r9   r    r    r    r!   rs   ¤  s
   rs   c                 C   s   t | dtjƒS )a  
    A validator that raises `ValueError` if the initializer is called with a
    number larger or equal to *val*.

    The validator uses `operator.lt` to compare the values.

    Args:
        val: Exclusive upper bound for values.

    .. versionadded:: 21.3.0
    ú<)rs   Úoperatorr   ©Úvalr    r    r!   r   ¶  s    c                 C   s   t | dtjƒS )a  
    A validator that raises `ValueError` if the initializer is called with a
    number greater than *val*.

    The validator uses `operator.le` to compare the values.

    Args:
        val: Inclusive upper bound for values.

    .. versionadded:: 21.3.0
    z<=)rs   ry   r   rz   r    r    r!   r   Å  s    c                 C   s   t | dtjƒS )a  
    A validator that raises `ValueError` if the initializer is called with a
    number smaller than *val*.

    The validator uses `operator.ge` to compare the values.

    Args:
        val: Inclusive lower bound for values

    .. versionadded:: 21.3.0
    z>=)rs   ry   r   rz   r    r    r!   r   Ô  s    c                 C   s   t | dtjƒS )a  
    A validator that raises `ValueError` if the initializer is called with a
    number smaller or equal to *val*.

    The validator uses `operator.ge` to compare the values.

    Args:
       val: Exclusive lower bound for values

    .. versionadded:: 21.3.0
    r6   )rs   ry   r   rz   r    r    r!   r   ã  s    c                   @   s"   e Zd Zeƒ Zdd„ Zdd„ ZdS )Ú_MaxLengthValidatorc                 C   s8   t |ƒ| jkr4d|j› d| j› dt |ƒ› �}t|ƒ‚dS )r%   úLength of 'z' must be <= rt   N)ÚlenÚ
max_lengthr,   rB   r/   r    r    r!   r5   ö  s    z_MaxLengthValidator.__call__c                 C   s   d| j › d�S )Nz<max_len validator for r6   )r   r8   r    r    r!   r9   þ  s    z_MaxLengthValidator.__repr__N)r;   r<   r=   r	   r   r5   r9   r    r    r    r!   r|   ò  s   r|   c                 C   s   t | ƒS )zï
    A validator that raises `ValueError` if the initializer is called
    with a string or iterable that is longer than *length*.

    Args:
        length (int): Maximum length of the string or iterable

    .. versionadded:: 21.3.0
    )r|   ©Úlengthr    r    r!   r     s    
c                   @   s"   e Zd Zeƒ Zdd„ Zdd„ ZdS )Ú_MinLengthValidatorc                 C   s8   t |ƒ| jk r4d|j› d| j› dt |ƒ› �}t|ƒ‚dS )r%   r}   z' must be >= rt   N)r~   Ú
min_lengthr,   rB   r/   r    r    r!   r5     s    z_MinLengthValidator.__call__c                 C   s   d| j › d�S )Nz<min_len validator for r6   )rƒ   r8   r    r    r!   r9     s    z_MinLengthValidator.__repr__N)r;   r<   r=   r	   rƒ   r5   r9   r    r    r    r!   r‚     s   r‚   c                 C   s   t | ƒS )zð
    A validator that raises `ValueError` if the initializer is called
    with a string or iterable that is shorter than *length*.

    Args:
        length (int): Minimum length of the string or iterable

    .. versionadded:: 22.1.0
    )r‚   r€   r    r    r!   r     s    
c                   @   s"   e Zd Zeƒ Zdd„ Zdd„ ZdS )Ú_SubclassOfValidatorc                 C   s<   t || jƒs8d|j› d| j›d|›d�}t||| j|ƒ‚dS )r%   r&   z' must be a subclass of r(   r)   N)Ú
issubclassr+   r,   r.   r/   r    r    r!   r5   0  s    üz_SubclassOfValidator.__call__c                 C   s   d| j ›d�S )Nz <subclass_of validator for type r6   r7   r8   r    r    r!   r9   =  s    z_SubclassOfValidator.__repr__Nr:   r    r    r    r!   r„   ,  s   r„   c                 C   s   t | ƒS )aà  
    A validator that raises a `TypeError` if the initializer is called with a
    wrong type for this particular attribute (checks are performed using
    `issubclass` therefore it's also valid to pass a tuple of types).

    Args:
        type (type | tuple[type, ...]): The type(s) to check for.

    Raises:
        TypeError:
            With a human readable error message, the attribute (of type
            `attrs.Attribute`), the expected type, and the value it got.
    )r„   r7   r    r    r!   Ú_subclass_ofA  s    r†   c                   @   sJ   e Zd Zeƒ Zeedƒd�Zeeee	ƒe
eƒd�d�Zdd„ Zdd„ Zd	S )
Ú_NotValidatorzCnot_ validator child '{validator!r}' did not raise a captured error)Ú	converterrm   rT   c                 C   sR   z|   |||¡ W n | jk
r(   Y n&X t| jj| j | jd�|| j || jƒ‚d S )N©rU   Ú	exc_types)rU   rŠ   rB   r4   rK   rV   r    r    r!   r5   b  s    þøz_NotValidator.__call__c                 C   s   d| j ›d| j›d�S )Nz<not_ validator wrapping z, capturing r6   r‰   r8   r    r    r!   r9   s  s    z_NotValidator.__repr__N)r;   r<   r=   r	   rU   r   r4   r   r†   Ú	Exceptionr   rX   rŠ   r5   r9   r    r    r    r!   r‡   R  s   ÿÿþÿr‡   )r4   rŠ   c                C   s4   zt |ƒ}W n tk
r&   |f}Y nX t| ||ƒS )a:  
    A validator that wraps and logically 'inverts' the validator passed to it.
    It will raise a `ValueError` if the provided validator *doesn't* raise a
    `ValueError` or `TypeError` (by default), and will suppress the exception
    if the provided validator *does*.

    Intended to be used with existing validators to compose logic without
    needing to create inverted variants, for example, ``not_(in_(...))``.

    Args:
        validator: A validator to be logically inverted.

        msg (str):
            Message to raise if validator fails. Formatted with keys
            ``exc_types`` and ``validator``.

        exc_types (tuple[type, ...]):
            Exception type(s) to capture. Other types raised by child
            validators will not be intercepted and pass through.

    Raises:
        ValueError:
            With a human readable error message, the attribute (of type
            `attrs.Attribute`), the validator that failed to raise an
            exception, the value it got, and the expected exception types.

    .. versionadded:: 22.2.0
    )rX   r.   r‡   )rU   r4   rŠ   r    r    r!   r   w  s
    c                   @   s"   e Zd Zeƒ Zdd„ Zdd„ ZdS )Ú_OrValidatorc              	   C   sZ   | j D ]4}z||||ƒ W n tk
r2   Y qY qX  d S qd| j ›d|›�}t|ƒ‚d S )NzNone of z satisfied for value )Ú
validatorsr‹   rB   )r0   r1   r2   r3   Úvr4   r    r    r!   r5   Ÿ  s    

z_OrValidator.__call__c                 C   s   d| j ›d�S )Nz<or validator wrapping r6   )r�   r8   r    r    r!   r9   «  s    z_OrValidator.__repr__N)r;   r<   r=   r	   r�   r5   r9   r    r    r    r!   rŒ   ›  s   rŒ   c                  G   s6   g }| D ] }|  t|tƒr |jn|g¡ qtt|ƒƒS )a  
    A validator that composes multiple validators into one.

    When called on a value, it runs all wrapped validators until one of them is
    satisfied.

    Args:
        validators (~collections.abc.Iterable[typing.Callable]):
            Arbitrary number of validators.

    Raises:
        ValueError:
            If no validator is satisfied. Raised with a human-readable error
            message listing all the wrapped validators and the value that
            failed all of them.

    .. versionadded:: 24.1.0
    )Úextendr*   rŒ   r�   rX   )r�   ÚvalsrŽ   r    r    r!   r   ¯  s    )r   N)N)N)5Ú__doc__ry   rG   Ú
contextlibr   r   Ú_configr   r   Ú_maker   r   r	   r
   Ú
convertersr   Ú
exceptionsr   Ú__all__r   r   r   r$   r   r?   r   rS   r   rY   r   r_   r   rc   r   rn   r   rs   r   r   r   r   r|   r   r‚   r   r„   r†   r‡   rB   r.   r   rŒ   r   r    r    r    r!   Ú<module>   s”   í

0#

$$