Use f-strings instead of .format or '%' which are new in Python 3.6

Author: JoshData

email_validator/__main__.py

@@ -30,7 +30,7 @@ def main(dns_resolver=None):
             try:
                 validate_email(email, dns_resolver=dns_resolver)
             except EmailNotValidError as e:
-                print("{} {}".format(email, e))
+                print(f"{email} {e}")
     else:
         # Validate the email address passed on the command line.
         email = sys.argv[1]

email_validator/deliverability.py

@@ -47,7 +47,7 @@ def validate_email_deliverability(domain, domain_i18n, timeout=None, dns_resolve
             mtas = [(preference, exchange) for preference, exchange in mtas
                     if exchange != ""]
             if len(mtas) == 0:  # null MX only, if there were no MX records originally a NoAnswer exception would have occurred
-                raise EmailUndeliverableError("The domain name %s does not accept email." % domain_i18n)
+                raise EmailUndeliverableError(f"The domain name {domain_i18n} does not accept email.")
 
             deliverability_info["mx"] = mtas
             deliverability_info["mx_fallback_type"] = None
@@ -73,7 +73,7 @@ def validate_email_deliverability(domain, domain_i18n, timeout=None, dns_resolve
                     # this domain is not deliverable, although the domain
                     # name has other records (otherwise NXDOMAIN would
                     # have been raised).
-                    raise EmailUndeliverableError("The domain name %s does not accept email." % domain_i18n)
+                    raise EmailUndeliverableError(f"The domain name {domain_i18n} does not accept email.")
 
             # Check for a SPF (RFC 7208) reject-all record ("v=spf1 -all") which indicates
             # no emails are sent from this domain (similar to a Null MX record
@@ -87,15 +87,15 @@ def validate_email_deliverability(domain, domain_i18n, timeout=None, dns_resolve
                     if value.startswith(b"v=spf1 "):
                         deliverability_info["spf"] = value.decode("ascii", errors='replace')
                         if value == b"v=spf1 -all":
-                            raise EmailUndeliverableError("The domain name %s does not send email." % domain_i18n)
+                            raise EmailUndeliverableError(f"The domain name {domain_i18n} does not send email.")
             except dns.resolver.NoAnswer:
                 # No TXT records means there is no SPF policy, so we cannot take any action.
                 pass
 
     except dns.resolver.NXDOMAIN:
         # The domain name does not exist --- there are no records of any sort
         # for the domain name.
-        raise EmailUndeliverableError("The domain name %s does not exist." % domain_i18n)
+        raise EmailUndeliverableError(f"The domain name {domain_i18n} does not exist.")
 
     except dns.resolver.NoNameservers:
         # All nameservers failed to answer the query. This might be a problem

email_validator/exceptions_types.py

@@ -65,7 +65,7 @@ def __self__(self):
         return self.normalized_email
 
     def __repr__(self):
-        return "<ValidatedEmail {}>".format(self.email)
+        return f"<ValidatedEmail {self.email}>"
 
     """For backwards compatibility, some fields are also exposed through a dict-like interface. Note
     that some of the names changed when they became attributes."""

email_validator/syntax.py

@@ -10,10 +10,9 @@
 def get_length_reason(addr, utf8=False, limit=EMAIL_MAX_LENGTH):
     """Helper function to return an error message related to invalid length."""
     diff = len(addr) - limit
-    reason = "({}{} character{} too many)"
     prefix = "at least " if utf8 else ""
     suffix = "s" if diff > 1 else ""
-    return reason.format(prefix, diff, suffix)
+    return f"({prefix}{diff} character{suffix} too many)"
 
 
 def safe_character_display(c):
@@ -23,9 +22,9 @@ def safe_character_display(c):
 
     # Construct a hex string in case the unicode name doesn't exist.
     if ord(c) < 0xFFFF:
-        h = "U+{:04x}".format(ord(c)).upper()
+        h = f"U+{ord(c):04x}".upper()
     else:
-        h = "U+{:08x}".format(ord(c)).upper()
+        h = f"U+{ord(c):08x}".upper()
 
     # Return the character name or, if it has no name, the hex string.
     return unicodedata.name(c, h)
@@ -55,7 +54,7 @@ def validate_email_local_part(local, allow_smtputf8=True, allow_empty_local=Fals
     # instead.
     if len(local) > LOCAL_PART_MAX_LENGTH:
         reason = get_length_reason(local, limit=LOCAL_PART_MAX_LENGTH)
-        raise EmailSyntaxError("The email address is too long before the @-sign {}.".format(reason))
+        raise EmailSyntaxError(f"The email address is too long before the @-sign {reason}.")
 
     # Check the local part against the non-internationalized regular expression.
     # Most email addresses match this regex so it's probably fastest to check this first.
@@ -231,7 +230,7 @@ def validate_email_domain_part(domain, test_environment=False, globally_delivera
     try:
         domain = idna.uts46_remap(domain, std3_rules=False, transitional=False)
     except idna.IDNAError as e:
-        raise EmailSyntaxError("The part after the @-sign contains invalid characters ({}).".format(str(e)))
+        raise EmailSyntaxError(f"The part after the @-sign contains invalid characters ({e}).")
 
     # The domain part is made up period-separated "labels." Each label must
     # have at least one character and cannot start or end with dashes, which
@@ -274,7 +273,7 @@ def validate_email_domain_part(domain, test_environment=False, globally_delivera
                 # one the user supplied. Also I'm not sure if the length check applies
                 # to the internationalized form, the IDNA ASCII form, or even both!
                 raise EmailSyntaxError("The email address is too long after the @-sign.")
-            raise EmailSyntaxError("The part after the @-sign contains invalid characters (%s)." % str(e))
+            raise EmailSyntaxError(f"The part after the @-sign contains invalid characters ({e}).")
 
         # Check the syntax of the string returned by idna.encode.
         # It should never fail.
@@ -291,14 +290,14 @@ def validate_email_domain_part(domain, test_environment=False, globally_delivera
     # is never reached for internationalized domains.)
     if len(ascii_domain) > DOMAIN_MAX_LENGTH:
         reason = get_length_reason(ascii_domain, limit=DOMAIN_MAX_LENGTH)
-        raise EmailSyntaxError("The email address is too long after the @-sign {}.".format(reason))
+        raise EmailSyntaxError(f"The email address is too long after the @-sign {reason}.")
 
     # Also check the label length limit.
     # (RFC 1035 2.3.1)
     for label in ascii_domain.split("."):
         if len(label) > DNS_LABEL_LENGTH_LIMIT:
             reason = get_length_reason(label, limit=DNS_LABEL_LENGTH_LIMIT)
-            raise EmailSyntaxError("After the @-sign, periods cannot be separated by so many characters {}.".format(reason))
+            raise EmailSyntaxError(f"After the @-sign, periods cannot be separated by so many characters {reason}.")
 
     if globally_deliverable:
         # All publicly deliverable addresses have domain named with at least
@@ -337,7 +336,7 @@ def validate_email_domain_part(domain, test_environment=False, globally_delivera
     try:
         domain_i18n = idna.decode(ascii_domain.encode('ascii'))
     except idna.IDNAError as e:
-        raise EmailSyntaxError("The part after the @-sign is not valid IDNA ({}).".format(str(e)))
+        raise EmailSyntaxError(f"The part after the @-sign is not valid IDNA ({e}).")
 
     # Check for invalid characters after normalization. These
     # should never arise. See the similar checks above.

email_validator/validate_email.py

@@ -101,15 +101,15 @@ def validate_email(
             reason = get_length_reason(ret.email, utf8=True)
         else:
             reason = "(when converted to IDNA ASCII)"
-        raise EmailSyntaxError("The email address is too long {}.".format(reason))
+        raise EmailSyntaxError(f"The email address is too long {reason}.")
     if len(ret.email.encode("utf8")) > EMAIL_MAX_LENGTH:
         if len(ret.email) > EMAIL_MAX_LENGTH:
             # If there are more than 254 characters, then the UTF-8
             # encoding is definitely going to be too long.
             reason = get_length_reason(ret.email, utf8=True)
         else:
             reason = "(when encoded in bytes)"
-        raise EmailSyntaxError("The email address is too long {}.".format(reason))
+        raise EmailSyntaxError(f"The email address is too long {reason}.")
 
     if check_deliverability and not test_environment:
         # Validate the email address's deliverability using DNS

tests/mocked_dns_response.py

@@ -103,7 +103,7 @@ def get(self, key):
         if (key[0], ANY, key[2]) in self.data and self.data[(key[0], ANY, key[2])] is None:
             raise dns.resolver.NXDOMAIN()
 
-        raise ValueError("Saved DNS data did not contain query: {}".format(key))
+        raise ValueError(f"Saved DNS data did not contain query: {key}")
 
     def put(self, key, value):
         # Build the DNS data by saving the live query response.

tests/test_deliverability.py

@@ -23,17 +23,17 @@ def test_deliverability_found():
 def test_deliverability_fails():
     # No MX record.
     domain = 'xkxufoekjvjfjeodlfmdfjcu.com'
-    with pytest.raises(EmailUndeliverableError, match='The domain name {} does not exist'.format(domain)):
+    with pytest.raises(EmailUndeliverableError, match=f'The domain name {domain} does not exist'):
         validate_email_deliverability(domain, domain, dns_resolver=RESOLVER)
 
     # Null MX record.
     domain = 'example.com'
-    with pytest.raises(EmailUndeliverableError, match='The domain name {} does not accept email'.format(domain)):
+    with pytest.raises(EmailUndeliverableError, match=f'The domain name {domain} does not accept email'):
         validate_email_deliverability(domain, domain, dns_resolver=RESOLVER)
 
     # No MX record, A record fallback, reject-all SPF record.
     domain = 'nellis.af.mil'
-    with pytest.raises(EmailUndeliverableError, match='The domain name {} does not send email'.format(domain)):
+    with pytest.raises(EmailUndeliverableError, match=f'The domain name {domain} does not send email'):
         validate_email_deliverability(domain, domain, dns_resolver=RESOLVER)
 
 

tests/test_syntax.py

@@ -559,4 +559,4 @@ def test_pyisemail_tests(email_input, status):
         with pytest.raises(EmailSyntaxError):
             validate_email(email_input, test_environment=True)
     else:
-        raise ValueError("status {} is not recognized".format(status))
+        raise ValueError(f"status {status} is not recognized")