Python django.core.validators 模块，ValidationError() 实例源码

def get_value(self, data):
        """Retrieves value from data with fallback to defaults"""
        # Retrieve raw config value, with fallback to default
        # when value is not defined
        try:
            raw_config_value = data[self.name]
        except KeyError:
            value = self.get_default_value()
        else:
            try:
                if self.multiple:
                    value = self.get_multiple_values(raw_config_value)
                else:
                    value = self.get_single_value(raw_config_value)
            except ValidationError:
                value = self.get_default_value()
        return value

def run_basic_validation(self, data):
        """
        Validates presence of variable and conversion.
        Returns converted value on success.
        """
        # Check presence of value
        try:
            raw_config_value = data[self.name]
        except KeyError:
            if self.required:
                raise ValidationError(self.error_messages['required'])
            value = self.get_default_value()
        else:
            # Validation errors are passed:
            if self.multiple:
                value = self.get_multiple_values(raw_config_value)
            else:
                value = self.get_single_value(raw_config_value)
        return value

def test_verify_user_empty_email(trans_member):
    """Test verifying user using `verify_user` function"""

    # Member has no EmailAddress set
    with pytest.raises(EmailAddress.DoesNotExist):
        EmailAddress.objects.get(user=trans_member)

    # Email is not set on User either
    assert trans_member.email == ''

    # Verify user - raises ValidationError
    with pytest.raises(ValidationError):
        accounts.utils.verify_user(trans_member)

    # User still has no email
    with pytest.raises(EmailAddress.DoesNotExist):
        EmailAddress.objects.get(user=trans_member)

def suitable_for_url_wtforms(form, field):
    """WTForm proxy for suitable_for_url"""
    return suitable_for_url(field.data)

# this cannot be serialized by django 1.8
# https://docs.djangoproject.com/en/1.8/topics/migrations/#serializing-values
# def reserved_names(*names):
#     # reserved_names =["all", "all-alpha"]
#     def test_reserved_names(value):
#         if value in names:
#             raise ValidationError(
#             "The name `%s' is reserved for system-internal use. "\
#             "Please choose another."
#             % value)
#         return
#     return test_reserved_names

def get_manifest(self, archive):
        try:
            with ZipFile(archive.temporary_file_path()) as plugin:
                print(plugin.namelist())
                prefix = self.get_prefix(plugin)
                prefix = prefix + '/' if len(prefix) else ''
                with plugin.open('{}manifest.json'.format(prefix)) as myfile:
                    manifest = json.loads(myfile.read())
                validate_manifest(manifest)
                return manifest
        except BadZipFile:
            raise ValidationError('Bad .zip format')
        except FileNotFoundError:
            raise ValidationError('Error with upload, please try again')
        except KeyError:
            raise ValidationError('No manifest.json found in archive')
        except json.JSONDecodeError:
            raise ValidationError('Error with manifest.json, bad Json Format')
        except avasdk.exceptions.ValidationError as e:
            raise ValidationError('Error in manifest.json ({})'.format(e))

def generate_unique_username(txts, regex=None):
    from .account.adapter import get_adapter
    adapter = get_adapter()
    username = _generate_unique_username_base(txts, regex)
    max_length = get_username_max_length()
    i = 0
    while True:
        try:
            if i:
                pfx = str(i + 1)
            else:
                pfx = ''
            ret = username[0:max_length - len(pfx)] + pfx
            return adapter.clean_username(ret)
        except ValidationError:
            i += 1

def test_name(self):
        plugin = Plugin()
        # check default value
        assert plugin.name is None
        # and that field validation fails on empty name
        with pytest.raises(ValidationError):
            plugin.full_clean()
        # trying to save a None name should raise a database error
        with pytest.raises(ValidationError):
            plugin.save()
        # also empty string must no be allowed
        plugin.name = ''
        # whereby saving empty name strings to database unfortunately works,
        # so never forget to call .full_clean() before custom .save() calls
        with pytest.raises(ValidationError):
            plugin.full_clean()
        plugin.name = 'test'
        plugin.full_clean()

def filter_email(organizations):
    """Filter the list of addresses to make sure it's an email-address"""
    valid_emails = []
    for organization in organizations:
        try:
            validate_email(organization.contact)
        except ValidationError:
            for extracted_email in organization.extract_emails():
                try:
                    validate_email(extracted_email)
                except ValidationError:
                    continue
                else:
                    valid_emails.append(extracted_email)
        else:
            valid_emails.append(organization.contact)

    return list(set(valid_emails))

def validate_org(self, attrs, source):
        org = attrs[source].lower()
        if org in RegistrationFormUserProfile._reserved_usernames:
            raise ValidationError(
                u"%s is a reserved name, please choose another" % org)
        elif not RegistrationFormUserProfile.legal_usernames_re.search(org):
            raise ValidationError(
                u'organization may only contain alpha-numeric characters and '
                u'underscores')
        try:
            User.objects.get(username=org)
        except User.DoesNotExist:
            attrs[source] = org

            return attrs
        raise ValidationError(u'%s already exists' % org)

def generate_unique_username(txts, regex=None):
    from .account.adapter import get_adapter
    adapter = get_adapter()
    username = _generate_unique_username_base(txts, regex)
    max_length = get_username_max_length()
    i = 0
    while True:
        try:
            if i:
                pfx = str(i + 1)
            else:
                pfx = ''
            ret = username[0:max_length - len(pfx)] + pfx
            return adapter.clean_username(ret)
        except ValidationError:
            i += 1

def validate(self):
        """
        Checks the data against validation settings for each variable.
        """
        errors = []
        for name, variable in self.variable_by_name.items():
            try:
                variable.validate_value(self.data)
            except ValidationError as e:
                for message in e.messages:
                    errors.append('{0}: {1}'.format(name, message))
        if errors:
            raise ValidationError(errors)

def get_single_value(self, raw_config_value):
        """Retrieves single value"""
        if self.choices:
            # Choices applied:
            # Map the value using choices, with fallback to the default
            # when value is not in available choices
            reversed_choice_dict = dict((v, k) for (k, v) in self.choices)
            try:
                value = reversed_choice_dict[raw_config_value]
            except KeyError:
                raise ValidationError(
                    self.error_messages['invalid_choice'] % {
                        'value': raw_config_value
                    }
                )
        else:
            # Converter applied:
            # Map the value using converter,
            # with fallback to the default when conversion fails
            try:
                value = self.converter(raw_config_value)
            except Exception as e:
                raise ValidationError(
                    self.error_messages['unable_to_process'] % {
                        'exc_type': e.__class__.__name__,
                        'exc_message': e.message
                    }
                )
        if callable(value):  # may be callable
            value = value()
        return value

def get_multiple_values(self, raw_config_values):
        """Retrieves multiple values"""
        try:
            iter(raw_config_values)
        except TypeError as e:
            raise ValidationError(
                self.error_messages['unable_to_process'] % {
                    'exc_type': e.__class__.__name__,
                    'exc_message': e.message
                }
            )
        return [
            self.get_single_value(raw_config_value)
            for raw_config_value in raw_config_values
        ]

def test_verify_user_duplicate_email(trans_member, member_with_email):
    """Test verifying user using `verify_user` function"""

    # trans_member steals member_with_email's email
    trans_member.email = member_with_email.email

    # And can't verify with it
    with pytest.raises(ValidationError):
        accounts.utils.verify_user(trans_member)

    # Email not verified
    with pytest.raises(EmailAddress.DoesNotExist):
        EmailAddress.objects.get(user=trans_member,
                                 primary=True, verified=True)

def test_update_user_email_bad_invalid_email(member_with_email):
    with pytest.raises(ValidationError):
        accounts.utils.update_user_email(member_with_email,
                                         "NOT_AN_EMAIL_ADDRESS")

def handle(self, **options):
        try:
            accounts.utils.update_user_email(self.get_user(options['user']),
                                             options['email'])
        except ValidationError as e:
            raise CommandError(e)
        self.stdout.write("Email updated: %s, %s\n" % (options['user'],
                                                       options['email']))

def validate_email_unique(email, for_user=None):
    """Validates an email to ensure it does not already exist in the system.

    :param email: Email address to validate for uniqueness.
    :param for_user: Optionally check an email address is unique to this user
    """
    existing_accounts = get_user_model().objects.filter(email=email)
    existing_email = EmailAddress.objects.filter(email=email)
    if for_user is not None:
        existing_accounts = existing_accounts.exclude(pk=for_user.pk)
        existing_email = existing_email.exclude(user=for_user)

    if existing_accounts.exists() or existing_email.exists():
        raise ValidationError("A user with that email address already exists")

def suitable_for_url(value):
    """Test that value contains onlys unreserved characters
    according to RFC3986/2.3:

    unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"

    """
    # also used by the clean_value_for_url function in forms.py
    regex = re.compile(r"^[a-zA-Z0-9_.~-]+$")
    match = regex.match(value)
    if not match:
        raise ValidationError("""This field can only include characters
                which are legal in a url: letters, digits and - . _ ~""")

def standard_reserved_names(value):
    reserved_names = ["all", "all-alpha"]
    if value in reserved_names:
        raise ValidationError(
            "The name `%s' is reserved for system-internal use. "
            "Please choose another."
            % value)

def test_reserved_names_validator(self):
        # validator = reserved_names("all", "all-alpha")
        for name in ["foo", "bar"]:  # good names
            self.assertIsNone(standard_reserved_names(name))
        for name in ["all", "all-alpha"]:  # bad names
            self.assertRaises(ValidationError, standard_reserved_names, name)

def test_suitable_for_url_validator(self):
        for name in ["aaa", "a-a", "a_a", "a~"]:  # good names
            self.assertIsNone(suitable_for_url(name))
        for name in ["A/A", u"??", "A A"]:  # bad names
            self.assertRaises(ValidationError, suitable_for_url, name)

def _is_url(path):
        try:
            URLValidator()(path)
            return True
        except ValidationError:
            return False

def __call__(self, value):
        super().__call__(value)
        if not zipfile.is_zipfile(value.temporary_file_path()):
            raise ValidationError(self.message_wrong_archive)

def get_readme(self, archive):
        try:
            with ZipFile(archive.temporary_file_path()) as plugin:
                prefix = self.get_prefix(plugin)
                with plugin.open('{}/README.md'.format(prefix)) as myfile:
                    readme = myfile.read()
                return readme
        except FileNotFoundError:
            raise ValidationError('Error with upload, please try again')
        except KeyError:
            return None

def test_max_choice(self):
        validator = MaxChoicesValidator(2)

        self.assertIsNone(validator('[0]'))
        self.assertIsNone(validator('[0, 1]'))

        with self.assertRaises(ValidationError):
            validator('[0, 1, 2]')

def test_min_choice(self):
        validator = MinChoicesValidator(2)

        self.assertIsNone(validator('[0, 1]'))
        self.assertIsNone(validator('[0, 1, 2]'))

        with self.assertRaises(ValidationError):
            validator('[0]')

def test_every_choice(self):
        validator = EverythingCheckedValidator(2)

        self.assertIsNone(validator('[0, 1]'))

        with self.assertRaises(ValidationError):
            validator('[0]')

        with self.assertRaises(ValidationError):
            validator('[0, 1, 2]')

def from_db_value(self, value, *args, **kwargs):
        if not value:
            return None
        if isinstance(value, Geoposition):
            return value
        if isinstance(value, list):
            return Geoposition(value[0], value[1])

        try:
            latitude, longitude = value.split(",")
            return Geoposition(latitude, longitude)
        except Exception: #pylint: disable=broad-except
            raise ValidationError(self.error_messages['invalid'], code='invalid')

def _extract_uuid(text):
    if isinstance(text, six.string_types):
        form_id_parts = text.split('/')

        if form_id_parts.__len__() < 2:
            raise ValidationError(_(u"Invalid formId %s." % text))

        text = form_id_parts[1]
        text = text[text.find("@key="):-1].replace("@key=", "")

        if text.startswith("uuid:"):
            text = text.replace("uuid:", "")

    return text

def validate_username(self, value):
        """Check that the username exists"""
        try:
            User.objects.get(username=value)
        except User.DoesNotExist:
            raise ValidationError(_(u"User '%(value)s' does not exist."
                                    % {"value": value}))

        return value

def validate_role(self, value):
        """check that the role exists"""

        if value not in ROLES:
            raise ValidationError(_(u"Unknown role '%(role)s'."
                                    % {"role": value}))

        return value

def validate_username(self, value):
        """Check that the username exists"""
        try:
            User.objects.get(username=value)
        except User.DoesNotExist:
            raise ValidationError(_(u"User '%(value)s' does not exist."
                                    % {"value": value}))

        return value

def validate_role(self, value):
        """check that the role exists"""

        if value not in ROLES:
            raise ValidationError(_(u"Unknown role '%(role)s'."
                                    % {"role": value}))

        return value

def get_user_from_uid(uid):
    if uid is None:
        raise ValidationError(_("uid is required!"))
    try:
        uid = urlsafe_base64_decode(uid)
        user = User.objects.get(pk=uid)
    except (TypeError, ValueError, OverflowError, User.DoesNotExist):
        raise ValidationError(_(u"Invalid uid %s") % uid)

    return user

def validate_email(self, value):
        users = User.objects.filter(email__iexact=value)

        if users.count() == 0:
            raise ValidationError(_(u"User '%(value)s' does not exist.")
                                  % {"value": value})

        return value

def validate(self, attrs):
        user = get_user_from_uid(attrs.get('uid'))
        value = attrs['token']

        if not default_token_generator.check_token(user, value):
            raise ValidationError(_("Invalid token: %s") % value)

        return attrs

def validate_org(self, value):
        org = value.lower()
        if org in RegistrationFormUserProfile._reserved_usernames:
            raise ValidationError(
                u"%s is a reserved name, please choose another" % org)
        elif not RegistrationFormUserProfile.legal_usernames_re.search(org):
            raise ValidationError(
                u'organization may only contain alpha-numeric characters and '
                u'underscores')

        if User.objects.filter(username=org).exists():
            raise ValidationError(u'%s already exists' % org)

        return value

def to_python(self,value):
        try:
            value = super(self.__class__,self).to_python(value)
        except (ValueError, ValidationError):
            key = self.to_field_name or 'pk'
            value = InvoiceItem.objects.filter(**{key: value})
            if not value.exists():
                raise ValidationError(self.error_messages['invalid_choice'], code='invalid_choice')
            else:
                value = value.first()
        return value

def valid_email_or_none(email):
    ret = None
    try:
        if email:
            validate_email(email)
            if len(email) <= EmailField().max_length:
                ret = email
    except ValidationError:
        pass
    return ret

def test_validation(self):
        repo = Repository(user=self.user)
        # don't allow empty strings
        repo.full_name = ''
        repo.provider = ''
        with pytest.raises(ValidationError):
            repo.full_clean()

def test_user(self):
        repo = Repository(full_name=self.full_name, provider=self.provider)
        # Don't allow saving if not linked to a user
        with pytest.raises(ValidationError):
            repo.full_clean()

def _check_remote_availability(self, config):
        """
        Check if remote ABACUS environment is ready.
        """
        try:
            validator = URLValidator()
            for url in config.get('ABACUS_REMOTE_SERVERS', ['']):
                validator(url)

            return True
        except ValidationError:
            return False

def cron_validator(crontab: str):
    try:
        Crontab(crontab)
    except ValueError as exc:
        raise validators.ValidationError(
            'Invalid crontab expression: {} ({})'.format(crontab, exc))

def validate_unique(self, exclude=None):
        if self.pk is None:
            queryset = OAuthUser.objects.filter(email__iexact=self.email)
        else:
            queryset = OAuthUser.objects.filter(email__iexact=self.email).exclude(pk=self.pk)
        if len(queryset) != 0:
            raise ValidationError(u'Email not unique')

def clean(self):
        if self.field.type != CF_TYPE_SELECT:
            raise ValidationError("Custom field choices can only be assigned to selection fields.")

def _extract_uuid(text):
    if isinstance(text, six.string_types):
        form_id_parts = text.split('/')

        if form_id_parts.__len__() < 2:
            raise ValidationError(_(u"Invalid formId %s." % text))

        text = form_id_parts[1]
        text = text[text.find("@key="):-1].replace("@key=", "")

        if text.startswith("uuid:"):
            text = text.replace("uuid:", "")

    return text

def validate_username(self, attrs, source):
        """Check that the username exists"""
        value = attrs[source]
        try:
            User.objects.get(username=value)
        except User.DoesNotExist:
            raise ValidationError(_(u"User '%(value)s' does not exist."
                                    % {"value": value}))

        return attrs

def validate_role(self, attrs, source):
        """check that the role exists"""
        value = attrs[source]

        if value not in ROLES:
            raise ValidationError(_(u"Unknown role '%(role)s'."
                                    % {"role": value}))

        return attrs