second commit
This commit is contained in:
678
env/lib/python3.11/site-packages/marshmallow/validate.py
vendored
Normal file
678
env/lib/python3.11/site-packages/marshmallow/validate.py
vendored
Normal file
@ -0,0 +1,678 @@
|
||||
"""Validation classes for various types of data."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
import typing
|
||||
from abc import ABC, abstractmethod
|
||||
from itertools import zip_longest
|
||||
from operator import attrgetter
|
||||
|
||||
from marshmallow import types
|
||||
from marshmallow.exceptions import ValidationError
|
||||
|
||||
_T = typing.TypeVar("_T")
|
||||
|
||||
|
||||
class Validator(ABC):
|
||||
"""Abstract base class for validators.
|
||||
|
||||
.. note::
|
||||
This class does not provide any validation behavior. It is only used to
|
||||
add a useful `__repr__` implementation for validators.
|
||||
"""
|
||||
|
||||
error = None # type: str | None
|
||||
|
||||
def __repr__(self) -> str:
|
||||
args = self._repr_args()
|
||||
args = f"{args}, " if args else ""
|
||||
|
||||
return f"<{self.__class__.__name__}({args}error={self.error!r})>"
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
"""A string representation of the args passed to this validator. Used by
|
||||
`__repr__`.
|
||||
"""
|
||||
return ""
|
||||
|
||||
@abstractmethod
|
||||
def __call__(self, value: typing.Any) -> typing.Any: ...
|
||||
|
||||
|
||||
class And(Validator):
|
||||
"""Compose multiple validators and combine their error messages.
|
||||
|
||||
Example: ::
|
||||
|
||||
from marshmallow import validate, ValidationError
|
||||
|
||||
|
||||
def is_even(value):
|
||||
if value % 2 != 0:
|
||||
raise ValidationError("Not an even value.")
|
||||
|
||||
|
||||
validator = validate.And(validate.Range(min=0), is_even)
|
||||
validator(-1)
|
||||
# ValidationError: ['Must be greater than or equal to 0.', 'Not an even value.']
|
||||
|
||||
:param validators: Validators to combine.
|
||||
:param error: Error message to use when a validator returns ``False``.
|
||||
"""
|
||||
|
||||
default_error_message = "Invalid value."
|
||||
|
||||
def __init__(self, *validators: types.Validator, error: str | None = None):
|
||||
self.validators = tuple(validators)
|
||||
self.error = error or self.default_error_message # type: str
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"validators={self.validators!r}"
|
||||
|
||||
def __call__(self, value: typing.Any) -> typing.Any:
|
||||
errors = []
|
||||
kwargs = {}
|
||||
for validator in self.validators:
|
||||
try:
|
||||
r = validator(value)
|
||||
if not isinstance(validator, Validator) and r is False:
|
||||
raise ValidationError(self.error)
|
||||
except ValidationError as err:
|
||||
kwargs.update(err.kwargs)
|
||||
if isinstance(err.messages, dict):
|
||||
errors.append(err.messages)
|
||||
else:
|
||||
# FIXME : Get rid of cast
|
||||
errors.extend(typing.cast(list, err.messages))
|
||||
if errors:
|
||||
raise ValidationError(errors, **kwargs)
|
||||
return value
|
||||
|
||||
|
||||
class URL(Validator):
|
||||
"""Validate a URL.
|
||||
|
||||
:param relative: Whether to allow relative URLs.
|
||||
:param absolute: Whether to allow absolute URLs.
|
||||
:param error: Error message to raise in case of a validation error.
|
||||
Can be interpolated with `{input}`.
|
||||
:param schemes: Valid schemes. By default, ``http``, ``https``,
|
||||
``ftp``, and ``ftps`` are allowed.
|
||||
:param require_tld: Whether to reject non-FQDN hostnames.
|
||||
"""
|
||||
|
||||
class RegexMemoizer:
|
||||
def __init__(self):
|
||||
self._memoized = {}
|
||||
|
||||
def _regex_generator(
|
||||
self, relative: bool, absolute: bool, require_tld: bool
|
||||
) -> typing.Pattern:
|
||||
hostname_variants = [
|
||||
# a normal domain name, expressed in [A-Z0-9] chars with hyphens allowed only in the middle
|
||||
# note that the regex will be compiled with IGNORECASE, so these are upper and lowercase chars
|
||||
(
|
||||
r"(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+"
|
||||
r"(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)"
|
||||
),
|
||||
# or the special string 'localhost'
|
||||
r"localhost",
|
||||
# or IPv4
|
||||
r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}",
|
||||
# or IPv6
|
||||
r"\[[A-F0-9]*:[A-F0-9:]+\]",
|
||||
]
|
||||
if not require_tld:
|
||||
# allow dotless hostnames
|
||||
hostname_variants.append(r"(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.?)")
|
||||
|
||||
absolute_part = "".join(
|
||||
(
|
||||
# scheme (e.g. 'https://', 'ftp://', etc)
|
||||
# this is validated separately against allowed schemes, so in the regex
|
||||
# we simply want to capture its existence
|
||||
r"(?:[a-z0-9\.\-\+]*)://",
|
||||
# userinfo, for URLs encoding authentication
|
||||
# e.g. 'ftp://foo:bar@ftp.example.org/'
|
||||
r"(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?",
|
||||
# netloc, the hostname/domain part of the URL plus the optional port
|
||||
r"(?:",
|
||||
"|".join(hostname_variants),
|
||||
r")",
|
||||
r"(?::\d+)?",
|
||||
)
|
||||
)
|
||||
relative_part = r"(?:/?|[/?]\S+)\Z"
|
||||
|
||||
if relative:
|
||||
if absolute:
|
||||
parts: tuple[str, ...] = (
|
||||
r"^(",
|
||||
absolute_part,
|
||||
r")?",
|
||||
relative_part,
|
||||
)
|
||||
else:
|
||||
parts = (r"^", relative_part)
|
||||
else:
|
||||
parts = (r"^", absolute_part, relative_part)
|
||||
|
||||
return re.compile("".join(parts), re.IGNORECASE)
|
||||
|
||||
def __call__(
|
||||
self, relative: bool, absolute: bool, require_tld: bool
|
||||
) -> typing.Pattern:
|
||||
key = (relative, absolute, require_tld)
|
||||
if key not in self._memoized:
|
||||
self._memoized[key] = self._regex_generator(
|
||||
relative, absolute, require_tld
|
||||
)
|
||||
|
||||
return self._memoized[key]
|
||||
|
||||
_regex = RegexMemoizer()
|
||||
|
||||
default_message = "Not a valid URL."
|
||||
default_schemes = {"http", "https", "ftp", "ftps"}
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
relative: bool = False,
|
||||
absolute: bool = True,
|
||||
schemes: types.StrSequenceOrSet | None = None,
|
||||
require_tld: bool = True,
|
||||
error: str | None = None,
|
||||
):
|
||||
if not relative and not absolute:
|
||||
raise ValueError(
|
||||
"URL validation cannot set both relative and absolute to False."
|
||||
)
|
||||
self.relative = relative
|
||||
self.absolute = absolute
|
||||
self.error = error or self.default_message # type: str
|
||||
self.schemes = schemes or self.default_schemes
|
||||
self.require_tld = require_tld
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"relative={self.relative!r}, absolute={self.absolute!r}"
|
||||
|
||||
def _format_error(self, value) -> str:
|
||||
return self.error.format(input=value)
|
||||
|
||||
def __call__(self, value: str) -> str:
|
||||
message = self._format_error(value)
|
||||
if not value:
|
||||
raise ValidationError(message)
|
||||
|
||||
# Check first if the scheme is valid
|
||||
if "://" in value:
|
||||
scheme = value.split("://")[0].lower()
|
||||
if scheme not in self.schemes:
|
||||
raise ValidationError(message)
|
||||
|
||||
regex = self._regex(self.relative, self.absolute, self.require_tld)
|
||||
|
||||
if not regex.search(value):
|
||||
raise ValidationError(message)
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class Email(Validator):
|
||||
"""Validate an email address.
|
||||
|
||||
:param error: Error message to raise in case of a validation error. Can be
|
||||
interpolated with `{input}`.
|
||||
"""
|
||||
|
||||
USER_REGEX = re.compile(
|
||||
r"(^[-!#$%&'*+/=?^`{}|~\w]+(\.[-!#$%&'*+/=?^`{}|~\w]+)*\Z" # dot-atom
|
||||
# quoted-string
|
||||
r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]'
|
||||
r'|\\[\001-\011\013\014\016-\177])*"\Z)',
|
||||
re.IGNORECASE | re.UNICODE,
|
||||
)
|
||||
|
||||
DOMAIN_REGEX = re.compile(
|
||||
# domain
|
||||
r"(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+"
|
||||
r"(?:[A-Z]{2,6}|[A-Z0-9-]{2,})\Z"
|
||||
# literal form, ipv4 address (SMTP 4.1.3)
|
||||
r"|^\[(25[0-5]|2[0-4]\d|[0-1]?\d?\d)"
|
||||
r"(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}\]\Z",
|
||||
re.IGNORECASE | re.UNICODE,
|
||||
)
|
||||
|
||||
DOMAIN_WHITELIST = ("localhost",)
|
||||
|
||||
default_message = "Not a valid email address."
|
||||
|
||||
def __init__(self, *, error: str | None = None):
|
||||
self.error = error or self.default_message # type: str
|
||||
|
||||
def _format_error(self, value: str) -> str:
|
||||
return self.error.format(input=value)
|
||||
|
||||
def __call__(self, value: str) -> str:
|
||||
message = self._format_error(value)
|
||||
|
||||
if not value or "@" not in value:
|
||||
raise ValidationError(message)
|
||||
|
||||
user_part, domain_part = value.rsplit("@", 1)
|
||||
|
||||
if not self.USER_REGEX.match(user_part):
|
||||
raise ValidationError(message)
|
||||
|
||||
if domain_part not in self.DOMAIN_WHITELIST:
|
||||
if not self.DOMAIN_REGEX.match(domain_part):
|
||||
try:
|
||||
domain_part = domain_part.encode("idna").decode("ascii")
|
||||
except UnicodeError:
|
||||
pass
|
||||
else:
|
||||
if self.DOMAIN_REGEX.match(domain_part):
|
||||
return value
|
||||
raise ValidationError(message)
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class Range(Validator):
|
||||
"""Validator which succeeds if the value passed to it is within the specified
|
||||
range. If ``min`` is not specified, or is specified as `None`,
|
||||
no lower bound exists. If ``max`` is not specified, or is specified as `None`,
|
||||
no upper bound exists. The inclusivity of the bounds (if they exist) is configurable.
|
||||
If ``min_inclusive`` is not specified, or is specified as `True`, then
|
||||
the ``min`` bound is included in the range. If ``max_inclusive`` is not specified,
|
||||
or is specified as `True`, then the ``max`` bound is included in the range.
|
||||
|
||||
:param min: The minimum value (lower bound). If not provided, minimum
|
||||
value will not be checked.
|
||||
:param max: The maximum value (upper bound). If not provided, maximum
|
||||
value will not be checked.
|
||||
:param min_inclusive: Whether the `min` bound is included in the range.
|
||||
:param max_inclusive: Whether the `max` bound is included in the range.
|
||||
:param error: Error message to raise in case of a validation error.
|
||||
Can be interpolated with `{input}`, `{min}` and `{max}`.
|
||||
"""
|
||||
|
||||
message_min = "Must be {min_op} {{min}}."
|
||||
message_max = "Must be {max_op} {{max}}."
|
||||
message_all = "Must be {min_op} {{min}} and {max_op} {{max}}."
|
||||
|
||||
message_gte = "greater than or equal to"
|
||||
message_gt = "greater than"
|
||||
message_lte = "less than or equal to"
|
||||
message_lt = "less than"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
min=None,
|
||||
max=None,
|
||||
*,
|
||||
min_inclusive: bool = True,
|
||||
max_inclusive: bool = True,
|
||||
error: str | None = None,
|
||||
):
|
||||
self.min = min
|
||||
self.max = max
|
||||
self.error = error
|
||||
self.min_inclusive = min_inclusive
|
||||
self.max_inclusive = max_inclusive
|
||||
|
||||
# interpolate messages based on bound inclusivity
|
||||
self.message_min = self.message_min.format(
|
||||
min_op=self.message_gte if self.min_inclusive else self.message_gt
|
||||
)
|
||||
self.message_max = self.message_max.format(
|
||||
max_op=self.message_lte if self.max_inclusive else self.message_lt
|
||||
)
|
||||
self.message_all = self.message_all.format(
|
||||
min_op=self.message_gte if self.min_inclusive else self.message_gt,
|
||||
max_op=self.message_lte if self.max_inclusive else self.message_lt,
|
||||
)
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"min={self.min!r}, max={self.max!r}, min_inclusive={self.min_inclusive!r}, max_inclusive={self.max_inclusive!r}"
|
||||
|
||||
def _format_error(self, value: _T, message: str) -> str:
|
||||
return (self.error or message).format(input=value, min=self.min, max=self.max)
|
||||
|
||||
def __call__(self, value: _T) -> _T:
|
||||
if self.min is not None and (
|
||||
value < self.min if self.min_inclusive else value <= self.min
|
||||
):
|
||||
message = self.message_min if self.max is None else self.message_all
|
||||
raise ValidationError(self._format_error(value, message))
|
||||
|
||||
if self.max is not None and (
|
||||
value > self.max if self.max_inclusive else value >= self.max
|
||||
):
|
||||
message = self.message_max if self.min is None else self.message_all
|
||||
raise ValidationError(self._format_error(value, message))
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class Length(Validator):
|
||||
"""Validator which succeeds if the value passed to it has a
|
||||
length between a minimum and maximum. Uses len(), so it
|
||||
can work for strings, lists, or anything with length.
|
||||
|
||||
:param min: The minimum length. If not provided, minimum length
|
||||
will not be checked.
|
||||
:param max: The maximum length. If not provided, maximum length
|
||||
will not be checked.
|
||||
:param equal: The exact length. If provided, maximum and minimum
|
||||
length will not be checked.
|
||||
:param error: Error message to raise in case of a validation error.
|
||||
Can be interpolated with `{input}`, `{min}` and `{max}`.
|
||||
"""
|
||||
|
||||
message_min = "Shorter than minimum length {min}."
|
||||
message_max = "Longer than maximum length {max}."
|
||||
message_all = "Length must be between {min} and {max}."
|
||||
message_equal = "Length must be {equal}."
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
min: int | None = None,
|
||||
max: int | None = None,
|
||||
*,
|
||||
equal: int | None = None,
|
||||
error: str | None = None,
|
||||
):
|
||||
if equal is not None and any([min, max]):
|
||||
raise ValueError(
|
||||
"The `equal` parameter was provided, maximum or "
|
||||
"minimum parameter must not be provided."
|
||||
)
|
||||
|
||||
self.min = min
|
||||
self.max = max
|
||||
self.error = error
|
||||
self.equal = equal
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"min={self.min!r}, max={self.max!r}, equal={self.equal!r}"
|
||||
|
||||
def _format_error(self, value: typing.Sized, message: str) -> str:
|
||||
return (self.error or message).format(
|
||||
input=value, min=self.min, max=self.max, equal=self.equal
|
||||
)
|
||||
|
||||
def __call__(self, value: typing.Sized) -> typing.Sized:
|
||||
length = len(value)
|
||||
|
||||
if self.equal is not None:
|
||||
if length != self.equal:
|
||||
raise ValidationError(self._format_error(value, self.message_equal))
|
||||
return value
|
||||
|
||||
if self.min is not None and length < self.min:
|
||||
message = self.message_min if self.max is None else self.message_all
|
||||
raise ValidationError(self._format_error(value, message))
|
||||
|
||||
if self.max is not None and length > self.max:
|
||||
message = self.message_max if self.min is None else self.message_all
|
||||
raise ValidationError(self._format_error(value, message))
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class Equal(Validator):
|
||||
"""Validator which succeeds if the ``value`` passed to it is
|
||||
equal to ``comparable``.
|
||||
|
||||
:param comparable: The object to compare to.
|
||||
:param error: Error message to raise in case of a validation error.
|
||||
Can be interpolated with `{input}` and `{other}`.
|
||||
"""
|
||||
|
||||
default_message = "Must be equal to {other}."
|
||||
|
||||
def __init__(self, comparable, *, error: str | None = None):
|
||||
self.comparable = comparable
|
||||
self.error = error or self.default_message # type: str
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"comparable={self.comparable!r}"
|
||||
|
||||
def _format_error(self, value: _T) -> str:
|
||||
return self.error.format(input=value, other=self.comparable)
|
||||
|
||||
def __call__(self, value: _T) -> _T:
|
||||
if value != self.comparable:
|
||||
raise ValidationError(self._format_error(value))
|
||||
return value
|
||||
|
||||
|
||||
class Regexp(Validator):
|
||||
"""Validator which succeeds if the ``value`` matches ``regex``.
|
||||
|
||||
.. note::
|
||||
|
||||
Uses `re.match`, which searches for a match at the beginning of a string.
|
||||
|
||||
:param regex: The regular expression string to use. Can also be a compiled
|
||||
regular expression pattern.
|
||||
:param flags: The regexp flags to use, for example re.IGNORECASE. Ignored
|
||||
if ``regex`` is not a string.
|
||||
:param error: Error message to raise in case of a validation error.
|
||||
Can be interpolated with `{input}` and `{regex}`.
|
||||
"""
|
||||
|
||||
default_message = "String does not match expected pattern."
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
regex: str | bytes | typing.Pattern,
|
||||
flags: int = 0,
|
||||
*,
|
||||
error: str | None = None,
|
||||
):
|
||||
self.regex = (
|
||||
re.compile(regex, flags) if isinstance(regex, (str, bytes)) else regex
|
||||
)
|
||||
self.error = error or self.default_message # type: str
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"regex={self.regex!r}"
|
||||
|
||||
def _format_error(self, value: str | bytes) -> str:
|
||||
return self.error.format(input=value, regex=self.regex.pattern)
|
||||
|
||||
@typing.overload
|
||||
def __call__(self, value: str) -> str: ...
|
||||
|
||||
@typing.overload
|
||||
def __call__(self, value: bytes) -> bytes: ...
|
||||
|
||||
def __call__(self, value):
|
||||
if self.regex.match(value) is None:
|
||||
raise ValidationError(self._format_error(value))
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class Predicate(Validator):
|
||||
"""Call the specified ``method`` of the ``value`` object. The
|
||||
validator succeeds if the invoked method returns an object that
|
||||
evaluates to True in a Boolean context. Any additional keyword
|
||||
argument will be passed to the method.
|
||||
|
||||
:param method: The name of the method to invoke.
|
||||
:param error: Error message to raise in case of a validation error.
|
||||
Can be interpolated with `{input}` and `{method}`.
|
||||
:param kwargs: Additional keyword arguments to pass to the method.
|
||||
"""
|
||||
|
||||
default_message = "Invalid input."
|
||||
|
||||
def __init__(self, method: str, *, error: str | None = None, **kwargs):
|
||||
self.method = method
|
||||
self.error = error or self.default_message # type: str
|
||||
self.kwargs = kwargs
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"method={self.method!r}, kwargs={self.kwargs!r}"
|
||||
|
||||
def _format_error(self, value: typing.Any) -> str:
|
||||
return self.error.format(input=value, method=self.method)
|
||||
|
||||
def __call__(self, value: typing.Any) -> typing.Any:
|
||||
method = getattr(value, self.method)
|
||||
|
||||
if not method(**self.kwargs):
|
||||
raise ValidationError(self._format_error(value))
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class NoneOf(Validator):
|
||||
"""Validator which fails if ``value`` is a member of ``iterable``.
|
||||
|
||||
:param iterable: A sequence of invalid values.
|
||||
:param error: Error message to raise in case of a validation error. Can be
|
||||
interpolated using `{input}` and `{values}`.
|
||||
"""
|
||||
|
||||
default_message = "Invalid input."
|
||||
|
||||
def __init__(self, iterable: typing.Iterable, *, error: str | None = None):
|
||||
self.iterable = iterable
|
||||
self.values_text = ", ".join(str(each) for each in self.iterable)
|
||||
self.error = error or self.default_message # type: str
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"iterable={self.iterable!r}"
|
||||
|
||||
def _format_error(self, value) -> str:
|
||||
return self.error.format(input=value, values=self.values_text)
|
||||
|
||||
def __call__(self, value: typing.Any) -> typing.Any:
|
||||
try:
|
||||
if value in self.iterable:
|
||||
raise ValidationError(self._format_error(value))
|
||||
except TypeError:
|
||||
pass
|
||||
|
||||
return value
|
||||
|
||||
|
||||
class OneOf(Validator):
|
||||
"""Validator which succeeds if ``value`` is a member of ``choices``.
|
||||
|
||||
:param choices: A sequence of valid values.
|
||||
:param labels: Optional sequence of labels to pair with the choices.
|
||||
:param error: Error message to raise in case of a validation error. Can be
|
||||
interpolated with `{input}`, `{choices}` and `{labels}`.
|
||||
"""
|
||||
|
||||
default_message = "Must be one of: {choices}."
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
choices: typing.Iterable,
|
||||
labels: typing.Iterable[str] | None = None,
|
||||
*,
|
||||
error: str | None = None,
|
||||
):
|
||||
self.choices = choices
|
||||
self.choices_text = ", ".join(str(choice) for choice in self.choices)
|
||||
self.labels = labels if labels is not None else []
|
||||
self.labels_text = ", ".join(str(label) for label in self.labels)
|
||||
self.error = error or self.default_message # type: str
|
||||
|
||||
def _repr_args(self) -> str:
|
||||
return f"choices={self.choices!r}, labels={self.labels!r}"
|
||||
|
||||
def _format_error(self, value) -> str:
|
||||
return self.error.format(
|
||||
input=value, choices=self.choices_text, labels=self.labels_text
|
||||
)
|
||||
|
||||
def __call__(self, value: typing.Any) -> typing.Any:
|
||||
try:
|
||||
if value not in self.choices:
|
||||
raise ValidationError(self._format_error(value))
|
||||
except TypeError as error:
|
||||
raise ValidationError(self._format_error(value)) from error
|
||||
|
||||
return value
|
||||
|
||||
def options(
|
||||
self,
|
||||
valuegetter: str | typing.Callable[[typing.Any], typing.Any] = str,
|
||||
) -> typing.Iterable[tuple[typing.Any, str]]:
|
||||
"""Return a generator over the (value, label) pairs, where value
|
||||
is a string associated with each choice. This convenience method
|
||||
is useful to populate, for instance, a form select field.
|
||||
|
||||
:param valuegetter: Can be a callable or a string. In the former case, it must
|
||||
be a one-argument callable which returns the value of a
|
||||
choice. In the latter case, the string specifies the name
|
||||
of an attribute of the choice objects. Defaults to `str()`
|
||||
or `str()`.
|
||||
"""
|
||||
valuegetter = valuegetter if callable(valuegetter) else attrgetter(valuegetter)
|
||||
pairs = zip_longest(self.choices, self.labels, fillvalue="")
|
||||
|
||||
return ((valuegetter(choice), label) for choice, label in pairs)
|
||||
|
||||
|
||||
class ContainsOnly(OneOf):
|
||||
"""Validator which succeeds if ``value`` is a sequence and each element
|
||||
in the sequence is also in the sequence passed as ``choices``. Empty input
|
||||
is considered valid.
|
||||
|
||||
:param iterable choices: Same as :class:`OneOf`.
|
||||
:param iterable labels: Same as :class:`OneOf`.
|
||||
:param str error: Same as :class:`OneOf`.
|
||||
|
||||
.. versionchanged:: 3.0.0b2
|
||||
Duplicate values are considered valid.
|
||||
.. versionchanged:: 3.0.0b2
|
||||
Empty input is considered valid. Use `validate.Length(min=1) <marshmallow.validate.Length>`
|
||||
to validate against empty inputs.
|
||||
"""
|
||||
|
||||
default_message = "One or more of the choices you made was not in: {choices}."
|
||||
|
||||
def _format_error(self, value) -> str:
|
||||
value_text = ", ".join(str(val) for val in value)
|
||||
return super()._format_error(value_text)
|
||||
|
||||
def __call__(self, value: typing.Sequence[_T]) -> typing.Sequence[_T]:
|
||||
# We can't use set.issubset because does not handle unhashable types
|
||||
for val in value:
|
||||
if val not in self.choices:
|
||||
raise ValidationError(self._format_error(value))
|
||||
return value
|
||||
|
||||
|
||||
class ContainsNoneOf(NoneOf):
|
||||
"""Validator which fails if ``value`` is a sequence and any element
|
||||
in the sequence is a member of the sequence passed as ``iterable``. Empty input
|
||||
is considered valid.
|
||||
|
||||
:param iterable iterable: Same as :class:`NoneOf`.
|
||||
:param str error: Same as :class:`NoneOf`.
|
||||
|
||||
.. versionadded:: 3.6.0
|
||||
"""
|
||||
|
||||
default_message = "One or more of the choices you made was in: {values}."
|
||||
|
||||
def _format_error(self, value) -> str:
|
||||
value_text = ", ".join(str(val) for val in value)
|
||||
return super()._format_error(value_text)
|
||||
|
||||
def __call__(self, value: typing.Sequence[_T]) -> typing.Sequence[_T]:
|
||||
for val in value:
|
||||
if val in self.iterable:
|
||||
raise ValidationError(self._format_error(value))
|
||||
return value
|
||||
Reference in New Issue
Block a user