a
    c	gNN                     @   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 g d
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 d%d& d&Zd'd( ZeddddG d)d* d*Z dQd+d,Z!eddddG d-d. d.Z"dRd/d0Z#eddddG d1d2 d2Z$d3d4 Z%d5d6 Z&d7d8 Z'd9d: Z(eddddG d;d< d<Z)d=d> Z*eddddG d?d@ d@Z+dAdB Z,eddddG dCdD dDZ-dEdF Z.eddddG dGdH dHZ/de0e1fdIdJdKZ2eddddG dLdM dMZ3dNdO Z4dS )Sz
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_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    R/var/www/html/llm_bihealth/app/venv/lib/python3.9/site-packages/attr/validators.pyr   *   s    r   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    	r   c                   c   s*   t d zdV  W t d n
t d 0 dS )z
    Context manager that disables running validators within its context.

    .. warning::

        This context manager is not thread-safe!

    .. versionadded:: 21.3.0
    FNTr   r    r    r    r!   r   H   s    r   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   )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}||vrDddtdd t|D }t|t	| t
rd|r^d}t|| }nt | |}|t ju r|j}n|t ju 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>       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(    


r   c                   @   s"   e Zd Ze Zdd Zdd ZdS )_OptionalValidatorc                 C   s   |d u 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>rU   r8   r    r    r!   r9      s    z_OptionalValidator.__repr__N)r;   r<   r=   r	   rV   r5   r9   r    r    r    r!   rT      s   rT   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tuplerT   r   rU   r    r    r!   r      s    r   c                   @   s,   e Zd Ze ZeddZdd Zdd ZdS )_InValidatorF)hashc                 C   sZ   z|| j v }W n ty$   d}Y n0 |sVd|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!   rZ      s   
rZ   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*   rX   dictrO   rY   rZ   )r]   Zrepr_optionsr    r    r!   r     s    r   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   rL   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    r   c                   @   s:   e Zd Zee dZedee dZdd Zdd Z	dS )_DeepIterablerU   NdefaultrV   c                 C   s4   | j du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 u rdn
d| j }d| d| jdS )N  z<deep_iterable validator forz iterables of r6   rh   )r0   Ziterable_identifierr    r    r!   r9   [  s    
z_DeepIterable.__repr__)
r;   r<   r=   r	   r   rj   r   ri   r5   r9   r    r    r    r!   rd   J  s   

rd   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*   rX   rY   r   rd   rj   ri   r    r    r!   r   g  s    r   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 )_DeepMappingrU   Nre   c                 C   sF   | j dur|  ||| |D ]$}| ||| | ||||  qdS rg   )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   )rq   rr   r8   r    r    r!   r9     s    z_DeepMapping.__repr__)r;   r<   r=   r	   r   rq   rr   r   rp   r5   r9   r    r    r    r!   ro   {  s
   ro   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
    )ro   )rq   rr   rp   r    r    r!   r     s    r   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'   rm   : 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 rm   r6   )rx   rw   r8   r    r    r!   r9     s    z_NumberValidator.__repr__N)	r;   r<   r=   r	   rw   rx   rv   r5   r9   r    r    r    r!   rt     s
   rt   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
    <)rt   operatorr   valr    r    r!   r     s    r   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<=)rt   rz   r   r{   r    r    r!   r     s    r   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>=)rt   rz   r   r{   r    r    r!   r     s    r   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   )rt   rz   r   r{   r    r    r!   r     s    r   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 <= ru   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    
r   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 >= ru   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    
r   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)	converterrn   rU   c                 C   sP   z|  ||| W n | jy&   Y n&0 t| jj| j | jd|| j || jd S )NrV   	exc_types)rV   r   rB   r4   rL   rW   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	   rV   r   r4   r   r   	Exceptionr   rY   r   r5   r9   r    r    r    r!   r   R  s   r   )r4   r   c                C   s2   zt |}W n ty$   |f}Y n0 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
    )rY   r.   r   )rV   r4   r   r    r    r!   r   w  s
    r   c                   @   s"   e Zd Ze Zdd Zdd ZdS )_OrValidatorc              	   C   sX   | j D ]2}z|||| W n ty0   Y qY q0  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   rY   )r   valsr   r    r    r!   r     s    r   )r   N)N)N)5__doc__rz   rH   
contextlibr   r   _configr   r   _maker   r   r	   r
   
convertersr   
exceptionsr   __all__r   r   r   r$   r   r?   r   rT   r   rZ   r   r`   r   rd   r   ro   r   rt   r   r   r   r   r}   r   r   r   r   r   r   rB   r.   r   r   r   r    r    r    r!   <module>   sn   

0#

$$