HEX

File: //usr/local/CyberCP/lib/python3.10/site-packages/attr/__pycache__/validators.cpython-310.pyc
o

�hNN�@s�dZddlZddlZddlmZddlmZddlmZmZddl	m
Z
mZmZm
Z
ddlmZdd	lmZgd
�Zdd�Zd
d�Zedd��Ze
dddd�Gdd�d��Zdd�Ze
dddd�Gdd�d��ZdPdd�Ze
dddd�Gdd�d��Zdd �Ze
dddd�Gd!d"�d"��Zd#d$�Ze
dddd�Gd%d&�d&��Zd'd(�Ze
dddd�Gd)d*�d*��Z dQd+d,�Z!e
dddd�Gd-d.�d.��Z"dQd/d0�Z#e
dddd�Gd1d2�d2��Z$d3d4�Z%d5d6�Z&d7d8�Z'd9d:�Z(e
dddd�Gd;d<�d<��Z)d=d>�Z*e
dddd�Gd?d@�d@��Z+dAdB�Z,e
dddd�GdCdD�dD��Z-dEdF�Z.e
dddd�GdGdH�dH��Z/de0e1fdI�dJdK�Z2e
dddd�GdLdM�dM��Z3dNdO�Z4dS)Rz
Commonly useful validators.
�N)�contextmanager)�Pattern�)�get_run_validators�set_run_validators)�
_AndValidator�and_�attrib�attrs)�default_if_none)�NotCallableError)r�
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_disabledcCst|�dS)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 �B/usr/local/CyberCP/lib/python3.10/site-packages/attr/validators.pyr*srcCst�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
    )rr r r r!r<s	rccs*�td�z
dVWtd�dStd�w)z�
    Context manager that disables running validators within its context.

    .. warning::

        This context manager is not thread-safe!

    .. versionadded:: 21.3.0
    FNTrr r r r!rHs
�rFT)�repr�slots�unsafe_hashc@�"eZdZe�Zdd�Zdd�ZdS)�_InstanceOfValidatorc	CsDt||j�s d|j�d|j�d|�d|j�d�	}t|||j|��dS)�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__cC�d|j�d�S)Nz <instance_of validator for type �>�r-�r2r r r!�__repr__k�z_InstanceOfValidator.__repr__N��__name__�
__module__�__qualname__r	r-r7r<r r r r!r&Z�
r&cC�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&r:r r r!ro�r)r"�frozenr#c@s(eZdZe�Ze�Zdd�Zdd�ZdS)�_MatchesReValidatorcCs<|�|�sd|j�d|jj�d|�d�}t|||j|��dS)r'r(z' must match regex z (z	 doesn't)N)�
match_funcr.�pattern�
ValueErrorr1r r r!r7�s
��z_MatchesReValidator.__call__cCr8)Nz"<matches_re validator for pattern r9)rHr;r r r!r<�r=z_MatchesReValidator.__repr__N)r?r@rAr	rHrGr7r<r r r r!rF�s

rFcCs�tjdtjtjf}||vr"d�d�tdd�t|�D����}t|��t	|t
�r2|r/d}t|��|}nt�||�}|tjurA|j}n|tjurJ|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, css�|]
}|r	|jp
dVqdS)�NoneN)r?)�.0�er r r!�	<genexpr>�s�zmatches_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�setrIr,rr0�compilerF)�regex�flags�func�valid_funcsr6rHrGr r r!r�s(��



rc@r%)�_OptionalValidatorcCs|durdS|�|||�dS�N��	validator�r2r3r4r5r r r!r7�sz_OptionalValidator.__call__cCr8)Nz<optional validator for z	 or None>r]r;r r r!r<�r=z_OptionalValidator.__repr__N)r?r@rAr	r^r7r<r r r r!r[�sr[cCs"t|ttf�r
tt|��St|�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�tupler[rr]r r r!r�src@s,eZdZe�Zedd�Zdd�Zdd�ZdS)�_InValidatorF)�hashcCsZz||jv}Wntyd}Ynw|s+d|j�d|j�d|�d�}t|||j|��dS)NFr(z
' must be in r*�))�optionsr0r.�_original_optionsrI)r2r3r4r5�
in_optionsr6r r r!r7�s���z_InValidator.__call__cCr8)Nz<in_ validator with options r9)rfr;r r r!r<�r=z_InValidator.__repr__N)r?r@rAr	rerfr7r<r r r r!rb�s

rbcCs&|}t|tttf�rt|�}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,r`�dictrUrarb)re�repr_optionsr r r!rs
rc@seZdZdd�Zdd�ZdS)�_IsCallableValidatorcCs,t|�sd}t|j|j||jd�|d��dS)r'z?'{name}' must be callable (got {value!r} that is a {actual!r}).)r.r5�actual)r6r5N)�callablerrRr.r/)r2r3r4r5�messager r r!r7&s�
���z_IsCallableValidator.__call__cCsdS)Nz<is_callable validator>r r;r r r!r<6sz_IsCallableValidator.__repr__N)r?r@rAr7r<r r r r!rj$srjcCst�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.
    )rjr r r r!r:s
rc@s:eZdZee�d�Zedee��d�Zdd�Zdd�Z	dS)�
_DeepIterabler]N��defaultr^cCs4|jdur|�|||�|D]	}|�|||�qdS�r'N��iterable_validator�member_validator)r2r3r4r5�memberr r r!r7Qs

�z_DeepIterable.__call__cCs.|jdurdnd|j��}d|�d|j�d�S)N�� z<deep_iterable validator forz iterables of r9rr)r2�iterable_identifierr r r!r<[s
�
���z_DeepIterable.__repr__)
r?r@rAr	rrtrrsr7r<r r r r!rnJs
�
rncCs t|ttf�rt|�}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,r`rarrn�rtrsr r r!r
gs
r
c@sFeZdZee�d�Zee�d�Zedee��d�Zdd�Z	dd�Z
dS)�_DeepMappingr]NrocCsF|jdur|�|||�|D]}|�|||�|�||||�qdSrq)�mapping_validator�
key_validator�value_validator)r2r3r4r5�keyr r r!r7�s
�z_DeepMapping.__call__cC�d|j�d|j�d�S)Nz,<deep_mapping validator for objects mapping z to r9)r|r}r;r r r!r<��z_DeepMapping.__repr__)r?r@rAr	rr|r}rr{r7r<r r r r!rz{srzcCst|||�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
    )rz)r|r}r{r r r!r�src@s.eZdZe�Ze�Ze�Zdd�Zdd�ZdS)�_NumberValidatorcCs<|�||j�sd|j�d|j�d|j�d|��}t|��dS)r'r(r)rw�: N)�compare_func�boundr.�
compare_oprIr1r r r!r7�s"�z_NumberValidator.__call__cCsd|j�d|j�d�S)Nz<Validator for x rwr9)r�r�r;r r r!r<�r�z_NumberValidator.__repr__N)	r?r@rAr	r�r�r�r7r<r r r r!r��sr�cC�t|dtj�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
    �<)r��operatorr��valr r r!r��rcCr�)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<=)r�r�rr�r r r!r�r�rcCr�)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>=)r�r�rr�r r r!r�r�rcCr�)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
    r9)r�r�rr�r r r!r�r�rc@r%)�_MaxLengthValidatorcCs8t|�|jkrd|j�d|j�dt|���}t|��dS)r'�Length of 'z
' must be <= r�N)�len�
max_lengthr.rIr1r r r!r7���z_MaxLengthValidator.__call__cC�d|j�d�S)Nz<max_len validator for r9)r�r;r r r!r<�r=z_MaxLengthValidator.__repr__N)r?r@rAr	r�r7r<r r r r!r���r�cCrC)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�
rc@r%)�_MinLengthValidatorcCs8t|�|jkrd|j�d|j�dt|���}t|��dS)r'r�z
' must be >= r�N)r��
min_lengthr.rIr1r r r!r7r�z_MinLengthValidator.__call__cCr�)Nz<min_len validator for r9)r�r;r r r!r<r=z_MinLengthValidator.__repr__N)r?r@rAr	r�r7r<r r r r!r�r�r�cCrC)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!rr�rc@r%)�_SubclassOfValidatorcCs<t||j�sd|j�d|j�d|�d�}t|||j|��dS)r'r(z' must be a subclass of r*r+N)�
issubclassr-r.r0r1r r r!r70s��z_SubclassOfValidator.__call__cCr8)Nz <subclass_of validator for type r9r:r;r r r!r<=r=z_SubclassOfValidator.__repr__Nr>r r r r!r�,rBr�cCrC)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�r:r r r!�_subclass_ofArDr�c@sJeZdZe�Zeed�d�Zeeee	�e
e�d�d�Zdd�Z
dd�Zd	S)
�
_NotValidatorzCnot_ validator child '{validator!r}' did not raise a captured error)�	converterryr]cCsNz	|�|||�Wn|jyYdSwt|jj|j|jd�||j||j��)N�r^�	exc_types)r^r�rIr6rRr_r r r!r7bs���z_NotValidator.__call__cCr)Nz<not_ validator wrapping z, capturing r9r�r;r r r!r<sr�z_NotValidator.__repr__N)r?r@rAr	r^rr6r
r��	Exceptionrrar�r7r<r r r r!r�Rs����r�)r6r�cCs2zt|�}Wnty|f}Ynwt|||�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
    )rar0r�)r^r6r�r r r!rws
�rc@r%)�_OrValidatorc	CsL|jD]}z
||||�WdStyYqwd|j�d|��}t|��)NzNone of z satisfied for value )�
validatorsr�rI)r2r3r4r5�vr6r r r!r7�s
��z_OrValidator.__call__cCr8)Nz<or validator wrapping r9)r�r;r r r!r<�r=z_OrValidator.__repr__N)r?r@rAr	r�r7r<r r r r!r��sr�cGs6g}|D]}|�t|t�r|jn|g�qtt|��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�ra)r��valsr�r r r!r�sr)rNr\)5�__doc__r�rN�
contextlibrr�_configrr�_makerrr	r
�
convertersr�
exceptionsr�__all__rrrr&rrFrr[rrbrrjrrnr
rzrr�rrrrr�rr�rr�r�r�rIr0rr�rr r r r!�<module>sp

0
#



$$