
    ")fL                     v   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 Zd Zed        Z eddd       G d d             Zd Z eddd       G d d             Zd=dZ eddd       G d d             Zd Z eddd       G d d             Zd Z eddd       G d d             Zd  Z eddd       G d! d"             Z d# Z! eddd       G d$ d%             Z"d>d&Z# eddd       G d' d(             Z$d>d)Z% eddd       G d* d+             Z&d, Z'd- Z(d. Z)d/ Z* eddd       G d0 d1             Z+d2 Z, eddd       G d3 d4             Z-d5 Z. eddd       G d6 d7             Z/d8 Z0 eddd       G d9 d:             Z1de2e3fd;d<Z4y)?z
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providesset_disabledc                     t        |         y)a  
    Globally disable or enable running validators.

    By default, they are run.

    :param disabled: If ``True``, disable running all validators.
    :type disabled: bool

    .. warning::

        This function is not thread-safe!

    .. versionadded:: 21.3.0
    Nr   )r   s    L/var/www/html/flask-app/venv/lib/python3.12/site-packages/attr/validators.pyr   r   +   s     8|$    c                      t                S )z
    Return a bool indicating whether validators are currently disabled or not.

    :return: ``True`` if validators are currently disabled.
    :rtype: bool

    .. versionadded:: 21.3.0
    )r    r#   r"   r   r   =   s     "###r#   c               #   b   K   t        d       	 d t        d       y# t        d       w xY ww)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   I   s)      u!4 4 s   / /,/FT)reprslotshashc                   &    e Zd Z e       Zd Zd Zy)_InstanceOfValidatorc                     t        || j                        sKdj                  |j                  | j                  |j                  |      }t        ||| j                  |      y)P
        We use a callable class to be able to change the ``__repr__``.
        z?'{name}' must be {type!r} (got {value!r} that is a {actual!r}).)nametypeactualvalueN)
isinstancer/   formatr.   	__class__	TypeErrorselfinstattrr1   msgs        r"   __call__z_InstanceOfValidator.__call___   sd     %+SZZYYYY	 [ C 			  ,r#   c                 "    d| j                   dS )Nz <instance_of validator for type >r/   r7   s    r"   __repr__z_InstanceOfValidator.__repr__q       1$))a@@r#   N__name__
__module____qualname__r
   r/   r;   r@   r%   r#   r"   r+   r+   [   s    8D$Ar#   r+   c                     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).

    :param type: The type to check for.
    :type type: type or tuple of type

    :raises TypeError: With a human readable error message, the attribute
        (of type `attrs.Attribute`), the expected type, and the value it
        got.
    )r+   r>   s    r"   r   r   u         %%r#   )r'   frozenr(   c                   4    e Zd Z e       Z e       Zd Zd Zy)_MatchesReValidatorc                     | j                  |      sJdj                  |j                  | j                  j                  |      }t	        ||| j                  |      y)r-   z9'{name}' must match regex {pattern!r} ({value!r} doesn't))r.   patternr1   N)
match_funcr3   r.   rL   
ValueErrorr6   s        r"   r;   z_MatchesReValidator.__call__   s_     u%MTTYY(<(<E U C 	 	 &r#   c                 "    d| j                   dS )Nz"<matches_re validator for pattern r=   )rL   r?   s    r"   r@   z_MatchesReValidator.__repr__   s    3DLL3C1EEr#   N)rC   rD   rE   r
   rL   rM   r;   r@   r%   r#   r"   rJ   rJ      s    hGJFr#   rJ   c           
         t         j                  dt         j                  t         j                  f}||vrDdj	                  dj                  t        d t        |      D                          }t        |      t        | t              r|rd}t        |      | }nt        j                  | |      }|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*.

    :param regex: a regex string or precompiled pattern to match against
    :param int flags: flags that will be passed to the underlying re function
        (default 0)
    :param callable func: 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              3   D   K   | ]  }|xr |j                   xs d   yw)NoneN)rC   ).0es     r"   	<genexpr>zmatches_re.<locals>.<genexpr>   s!     Laq'QZZ161Ls    zR'flags' can only be used with a string pattern; pass flags to re.compile() instead)re	fullmatchsearchmatchr3   joinsortedsetrN   r2   r   r5   compilerJ   )regexflagsfuncvalid_funcsr:   rL   rM   s          r"   r   r      s      <<ryy"((;K;)00IIL3{;KLL

 o%!fCC. **UE*rxx]]
		^^
&&
w
33r#   c                   &    e Zd Z e       Zd Zd Zy)_ProvidesValidatorc                     | j                   j                  |      s@dj                  |j                  | j                   |      }t	        ||| j                   |      y)r-   z<'{name}' must provide {interface!r} which {value!r} doesn't.)r.   	interfacer1   N)re   
providedByr3   r.   r5   r6   s        r"   r;   z_ProvidesValidator.__call__   s_     ~~((/PWWYY$.. X C 	 	 0r#   c                 "    d| j                   dS )Nz"<provides validator for interface r=   )re   r?   s    r"   r@   z_ProvidesValidator.__repr__   s    3DNN3EQGGr#   N)rC   rD   rE   r
   re   r;   r@   r%   r#   r"   rc   rc      s    IHr#   rc   c                 P    ddl }|j                  dt        d       t        |       S )aE  
    A validator that raises a `TypeError` if the initializer is called
    with an object that does not provide the requested *interface* (checks are
    performed using ``interface.providedBy(value)`` (see `zope.interface
    <https://zopeinterface.readthedocs.io/en/latest/>`_).

    :param interface: The interface to check for.
    :type interface: ``zope.interface.Interface``

    :raises TypeError: With a human readable error message, the attribute
        (of type `attrs.Attribute`), the expected interface, and the
        value it got.

    .. deprecated:: 23.1.0
    r   NzZattrs's zope-interface support is deprecated and will be removed in, or after, April 2024.   )
stacklevel)warningswarnDeprecationWarningrc   )re   rk   s     r"   r   r      s0      MM	 	   i((r#   c                   &    e Zd Z e       Zd Zd Zy)_OptionalValidatorc                 0    |y | j                  |||       y N	validatorr7   r8   r9   r1   s       r"   r;   z_OptionalValidator.__call__   s    =tT5)r#   c                 "    d| j                   dS )Nz<optional validator for z	 or None>rr   r?   s    r"   r@   z_OptionalValidator.__repr__  s    )$..);9EEr#   N)rC   rD   rE   r
   rs   r;   r@   r%   r#   r"   ro   ro      s    I*Fr#   ro   c                 l    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.

    :param Callable | tuple[Callable] | list[Callable] validator: 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.
    )r2   listtuplero   r   rr   s    r"   r   r     s-     )dE]+!-	":;;i((r#   c                   &    e Zd Z e       Zd Zd Zy)_InValidatorc                     	 || j                   v }|s8d|j                   d| j                   d|d}t        ||| j                   |      y # t        $ r d}Y Hw xY w)NF'z' must be in  (got ))optionsr5   r.   rN   )r7   r8   r9   r1   
in_optionsr:   s         r"   r;   z_InValidator.__call__  su    	$,,.J dii[dll-=VE9ANC	    	J	s   A AAc                 "    d| j                   dS )Nz<in_ validator with options r=   r   r?   s    r"   r@   z_InValidator.__repr__.  s    -dll-=Q??r#   N)rC   rD   rE   r
   r   r;   r@   r%   r#   r"   rz   rz     s    hG@r#   rz   c                     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``.

    :param options: Allowed options.
    :type options: list, tuple, `enum.Enum`, ...

    :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.
    )rz   r   s    r"   r   r   2  s    &   r#   c                       e Zd Zd Zd Zy)_IsCallableValidatorc                     t        |      s5d}t        |j                  |j                  ||j                        |      y)r-   z?'{name}' must be callable (got {value!r} that is a {actual!r}).)r.   r1   r0   )r:   r1   N)callabler   r3   r.   r4   )r7   r8   r9   r1   messages        r"   r;   z_IsCallableValidator.__call__J  sN     8  #NN% #  	  r#   c                      y)Nz<is_callable validator>r%   r?   s    r"   r@   z_IsCallableValidator.__repr__Z  s    (r#   N)rC   rD   rE   r;   r@   r%   r#   r"   r   r   H  s     )r#   r   c                      t               S )ax  
    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                   ^    e Zd Z e e             Z ed e e                   Zd Zd Z	y)_DeepIterablerr   Ndefaultrs   c                 v    | j                   | j                  |||       |D ]  }| j                  |||        yr-   Niterable_validatormember_validator)r7   r8   r9   r1   members        r"   r;   z_DeepIterable.__call__t  sC     "".##D$6 	6F!!$f5	6r#   c                 b    | j                   dnd| j                   }d| d| j                  dS )N  z<deep_iterable validator forz iterables of r=   r   )r7   iterable_identifiers     r"   r@   z_DeepIterable.__repr__~  sP     &&. T,,/0 	 ++>*?T225Q8	
r#   )
rC   rD   rE   r
   r   r   r   r   r;   r@   r%   r#   r"   r   r   m  s0    6 76	
r#   r   c                 V    t        | t        t        f      rt        |  } t	        | |      S )a4  
    A validator that performs deep validation of an iterable.

    :param member_validator: Validator(s) to apply to iterable members
    :param iterable_validator: Validator to apply to iterable itself
        (optional)

    .. versionadded:: 19.1.0

    :raises TypeError: if any sub-validators fail
    )r2   rw   rx   r	   r   r   r   s     r"   r   r     s.     "T5M2!12)+=>>r#   c                   z    e Zd Z e e             Z e e             Z ed e e                   Zd Z	d Z
y)_DeepMappingrr   Nr   c                     | j                   | j                  |||       |D ]+  }| j                  |||       | j                  ||||          - yr   )mapping_validatorkey_validatorvalue_validator)r7   r8   r9   r1   keys        r"   r;   z_DeepMapping.__call__  sY     !!-""4u5 	9CtT3/  tU3Z8	9r#   c                 P    dj                  | j                  | j                        S )NzA<deep_mapping validator for objects mapping {key!r} to {value!r}>)r   r1   )r3   r   r   r?   s    r"   r@   z_DeepMapping.__repr__  s%    O
&T''t/C/C&
D	Er#   )rC   rD   rE   r
   r   r   r   r   r   r;   r@   r%   r#   r"   r   r     s9    []3M{}5Otx7NO	9Er#   r   c                     t        | ||      S )a}  
    A validator that performs deep validation of a dictionary.

    :param key_validator: Validator to apply to dictionary keys
    :param value_validator: Validator to apply to dictionary values
    :param mapping_validator: Validator to apply to top-level mapping
        attribute (optional)

    .. versionadded:: 19.1.0

    :raises TypeError: if any sub-validators fail
    )r   )r   r   r   s      r"   r   r     s     8IJJr#   c                   B    e Zd Z e       Z e       Z e       Zd Zd Zy)_NumberValidatorc                     | j                  || j                        s7d|j                   d| j                   d| j                   d| }t	        |      y)r-   r|   z
' must be r   : N)compare_funcboundr.   
compare_oprN   r6   s        r"   r;   z_NumberValidator.__call__  sR       

3dii[
4??*;1TZZL5'RCS/! 4r#   c                 <    d| j                    d| j                   dS )Nz<Validator for x r   r=   )r   r   r?   s    r"   r@   z_NumberValidator.__repr__  s     "4??"31TZZLBBr#   N)	rC   rD   rE   r
   r   r   r   r;   r@   r%   r#   r"   r   r     s"    HEJ8L"Cr#   r   c                 8    t        | dt        j                        S )z
    A validator that raises `ValueError` if the initializer is called
    with a number larger or equal to *val*.

    :param val: Exclusive upper bound for values

    .. versionadded:: 21.3.0
    <)r   operatorr   vals    r"   r   r          Chkk22r#   c                 8    t        | dt        j                        S )z
    A validator that raises `ValueError` if the initializer is called
    with a number greater than *val*.

    :param val: Inclusive upper bound for values

    .. versionadded:: 21.3.0
    z<=)r   r   r   r   s    r"   r   r          Cx{{33r#   c                 8    t        | dt        j                        S )z
    A validator that raises `ValueError` if the initializer is called
    with a number smaller than *val*.

    :param val: Inclusive lower bound for values

    .. versionadded:: 21.3.0
    z>=)r   r   r   r   s    r"   r   r     r   r#   c                 8    t        | dt        j                        S )z
    A validator that raises `ValueError` if the initializer is called
    with a number smaller or equal to *val*.

    :param val: Exclusive lower bound for values

    .. versionadded:: 21.3.0
    r=   )r   r   r   r   s    r"   r   r     r   r#   c                   &    e Zd Z e       Zd Zd Zy)_MaxLengthValidatorc                     t        |      | j                  kD  r3d|j                   d| j                   dt        |       }t        |      y)r-   Length of 'z' must be <= r   N)len
max_lengthr.   rN   r6   s        r"   r;   z_MaxLengthValidator.__call__  H     u:'		{-7H3u:,WCS/! (r#   c                 "    d| j                    dS )Nz<max_len validator for r=   )r   r?   s    r"   r@   z_MaxLengthValidator.__repr__      ((9;;r#   N)rC   rD   rE   r
   r   r;   r@   r%   r#   r"   r   r         J"<r#   r   c                     t        |       S )z
    A validator that raises `ValueError` if the initializer is called
    with a string or iterable that is longer than *length*.

    :param int length: Maximum length of the string or iterable

    .. versionadded:: 21.3.0
    )r   lengths    r"   r   r          v&&r#   c                   &    e Zd Z e       Zd Zd Zy)_MinLengthValidatorc                     t        |      | j                  k  r3d|j                   d| j                   dt        |       }t        |      y)r-   r   z' must be >= r   N)r   
min_lengthr.   rN   r6   s        r"   r;   z_MinLengthValidator.__call__$  r   r#   c                 "    d| j                    dS )Nz<min_len validator for r=   )r   r?   s    r"   r@   z_MinLengthValidator.__repr__,  r   r#   N)rC   rD   rE   r
   r   r;   r@   r%   r#   r"   r   r      r   r#   r   c                     t        |       S )z
    A validator that raises `ValueError` if the initializer is called
    with a string or iterable that is shorter than *length*.

    :param int length: Minimum length of the string or iterable

    .. versionadded:: 22.1.0
    )r   r   s    r"   r   r   0  r   r#   c                   &    e Zd Z e       Zd Zd Zy)_SubclassOfValidatorc                     t        || j                        s8d|j                   d| j                  d|d}t        ||| j                  |      y)r-   r|   z' must be a subclass of r}   z).N)
issubclassr/   r.   r5   r6   s        r"   r;   z_SubclassOfValidator.__call__@  sX     %+dii[ 8VE9TVWC			  ,r#   c                 "    d| j                   dS )Nz <subclass_of validator for type r=   r>   r?   s    r"   r@   z_SubclassOfValidator.__repr__M  rA   r#   NrB   r%   r#   r"   r   r   <  s    8DAr#   r   c                     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).

    :param type: The type to check for.
    :type type: type or tuple of types

    :raises TypeError: With a human readable error message, the attribute
        (of type `attrs.Attribute`), the expected type, and the value it
        got.
    )r   r>   s    r"   _subclass_ofr   Q  rG   r#   c                   ~    e Zd Z e       Z e ed            Z e e ee	       e
e                  Zd Zd Zy)_NotValidatorzCnot_ validator child '{validator!r}' did not raise a captured error)	converterr   rr   c                     	 | j                  |||       t        | j                  j                  | j                   | j                        || j                   || j                        # | j                  $ r Y y w xY w)N)rs   	exc_types)rs   rN   r:   r3   r   rt   s       r"   r;   z_NotValidator.__call__q  sw    	NN4u- "nn"nn    	 	 ~~ 		s   A' 'A98A9c                 P    dj                  | j                  | j                        S )Nz;<not_ validator wrapping {what!r}, capturing {exc_types!r}>)whatr   )r3   rs   r   r?   s    r"   r@   z_NotValidator.__repr__  s'    I
&nn  
	
r#   N)rC   rD   rE   r
   rs   r   r:   r   r   	Exceptionr   rx   r   r;   r@   r%   r#   r"   r   r   a  sN    I
!-
C ))4*51
I"
r#   r   )r:   r   c                X    	 t        |      }t        | ||      S # t        $ r |f}Y w xY w)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_(...))``.

    :param validator: A validator to be logically inverted.
    :param msg: Message to raise if validator fails.
        Formatted with keys ``exc_types`` and ``validator``.
    :type msg: str
    :param exc_types: 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   r5   r   )rs   r:   r   s      r"   r   r     s:    4!)$	 C33  !L	!s    )))r   Nrq   )5__doc__r   rV   
contextlibr   r   _configr   r   _maker   r	   r
   r   
convertersr   
exceptionsr   __all__r   r   r   r+   r   rJ   r   rc   r   ro   r   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rN   r5   r   r%   r#   r"   <module>r      s}  
  	 %  ; 5 5 ' (.%$	$ ! !" ED)A A *A2&  E$d+F F ,F.(4V ED)H H *H,)6 ED)
F 
F *
F)& ED)@ @ *@,!, ET*) ) +)*" ED)
 
 *
8?" ED)E E *E,K  E$d+C C ,C"	3	4	4	3 E$d+< < ,<	' E$d+< < ,<	' ED)A A *A(&  ED)&
 &
 *&
R  J	+B 4r#   