U ku fL@sdZddlZddlZddlmZddlmZddlmZmZddl m Z m Z m Z m Z ddlmZdd lmZd d d d dddddddddddddddgZddZddZedd Ze d d!d!d"Gd#d$d$Zd%dZe d d!d!d&Gd'd(d(ZdPd)dZe d d!d!d"Gd*d+d+Zd,dZe d d!d!d"Gd-d.d.Zd/dZe d d!d!d"Gd0d1d1Zd2dZe d d d!d"Gd3d4d4Z d5dZ!e d d!d!d"Gd6d7d7Z"dQd8d Z#e d d!d!d"Gd9d:d:Z$dRd;d Z%e d d!d!d&GddZ'd?dZ(d@dZ)dAdZ*e d d!d!d&GdBdCdCZ+dDdZ,e d d!d!d&GdEdFdFZ-dGdZ.e d d!d!d"GdHdIdIZ/dJdKZ0e d d!d!d"GdLdMdMZ1de2e3fdNdOdZ4dS)Sz Commonly useful validators. N)contextmanager)Pattern)get_run_validatorsset_run_validators) _AndValidatorand_attribattrs)default_if_none)NotCallableErrorr deep_iterable deep_mappingdisabledge get_disabledgtin_ instance_of is_callablelelt matches_remax_lenmin_lennot_optionalprovides set_disabledcCst| dS)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 Nr)rr 3/tmp/pip-unpacked-wheel-563mi0su/attr/validators.pyr+scCst 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 )rr r r r!r=s ccs"tdz dVW5tdXdS)z Context manager that disables running validators within its context. .. warning:: This context manager is not thread-safe! .. versionadded:: 21.3.0 FTNrr r r r!rIs  FT)reprslotshashc@s"eZdZeZddZddZdS)_InstanceOfValidatorcCs8t||js4dj|j|j|j|d}t|||j|dS)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}).)nametypeactualvalueN) isinstancer(formatr' __class__ TypeErrorselfinstattrr*msgr r r!__call___s z_InstanceOfValidator.__call__cCsd|jdS)Nz r(r0r r r!__repr__qsz_InstanceOfValidator.__repr__N__name__ __module__ __qualname__r r(r4r8r r r r!r%[sr%cCst|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%r6r r r!rus )r"frozenr#c@s(eZdZeZeZddZddZdS)_MatchesReValidatorcCs4||s0dj|j|jj|d}t|||j|dS)r&z9'{name}' must match regex {pattern!r} ({value!r} doesn't))r'patternr*N) match_funcr,r'r? ValueErrorr/r r r!r4s z_MatchesReValidator.__call__cCsd|jdS)Nz"sr>cCstjdtjtjf}||krDddtddt|D}t|t |t rd|r^d}t ||}n t ||}|tjkr|j}n|tjkr|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, css|]}|r|jpdVqdS)NoneN)r:).0er r r! szmatches_re..zR'flags' can only be used with a string pattern; pass flags to re.compile() instead)re fullmatchsearchmatchr,joinsortedsetrAr+rr.compiler>)regexflagsfuncZ valid_funcsr3r?r@r r r!rs(    c@s"eZdZeZddZddZdS)_ProvidesValidatorcCs4|j|s0dj|j|j|d}t|||j|dS)r&z<'{name}' must provide {interface!r} which {value!r} doesn't.)r' interfacer*N)rRZ providedByr,r'r.r/r r r!r4s z_ProvidesValidator.__call__cCsd|jdS)Nz"`_). :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 rNzZattrs's zope-interface support is deprecated and will be removed in, or after, April 2024.) stacklevel)warningswarnDeprecationWarningrQ)rRrUr r r!rsc@s"eZdZeZddZddZdS)_OptionalValidatorcCs|dkr dS||||dS)N validatorr0r1r2r*r r r!r4sz_OptionalValidator.__call__cCsd|jdS)NzrYr7r r r!r8sz_OptionalValidator.__repr__N)r:r;r<r rZr4r8r r r r!rXsrXcCs"t|ttfrtt|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. :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. )r+listtuplerXrrYr r r!rs  c@s"eZdZeZddZddZdS) _InValidatorcCs\z||jk}Wntk r&d}YnX|sXd|jd|jd|d}t|||j|dS)NF'z ' must be in  (got ))optionsr.r'rA)r0r1r2r*Z in_optionsr3r r r!r4s z_InValidator.__call__cCsd|jdS)Nzr r7r r r!r8Zsz_IsCallableValidator.__repr__N)r:r;r<r4r8r r r r!rdHsrdcCstS)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. )rdr r r r!r^s c@s:eZdZeedZedeedZddZddZ dS) _DeepIterablerYNdefaultrZcCs4|jdk r|||||D]}||||qdSr&Niterable_validatormember_validator)r0r1r2r*memberr r r!r4ts z_DeepIterable.__call__cCs.|jdkrdn d|j}d|d|jdS)N z)rvr*)r,rtrur7r r r!r8s z_DeepMapping.__repr__) r:r;r<r rrtrurrsr4r8r r r r!rrs    rrcCs 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 )rr)rtrursr r r!rs c@s.eZdZeZeZeZddZddZdS)_NumberValidatorcCs<|||js8d|jd|jd|jd|}t|dS)r&r_z ' must be rp: N) compare_funcboundr' compare_oprAr/r r r!r4s"z_NumberValidator.__call__cCsd|jd|jdS)Nz=)rwr}rr~r r r!rs cCst|dtjS)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 r5)rwr}rr~r r r!rs c@s"eZdZeZddZddZdS)_MaxLengthValidatorcCs8t||jkr4d|jd|jdt|}t|dS)r& Length of 'z ' must be <= rxN)len max_lengthr'rAr/r r r!r4sz_MaxLengthValidator.__call__cCsd|jdS)Nz= rxN)r min_lengthr'rAr/r r r!r4$sz_MinLengthValidator.__call__cCsd|jdS)Nz)whatr)r,rZrr7r r r!r8s z_NotValidator.__repr__N)r:r;r<r rZr r3r r Exceptionrr]rr4r8r r r r!rasr)r3rcCs4z t|}Wntk r&|f}YnXt|||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_(...))``. :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 )r]r.r)rZr3rr r r!rs   )rN)N)N)5__doc__r}rF contextlibrr_configrr_makerrr r convertersr exceptionsr __all__rrrr%rr>rrQrrXrr^rrdrrgr rrrrwrrrrrrrrrrrrAr.rr r r r!s         +                 )