Remove local part length check unless new strict flag is given, fixes #158

Author: JoshData

README.md

@@ -150,6 +150,7 @@ The `validate_email` function also accepts the following keyword arguments
 `allow_empty_local=False`: Set to `True` to allow an empty local part (i.e.
     `@example.com`), e.g. for validating Postfix aliases.
 
+`strict=False`: Set to `True` to perform additional syntax checks (currently only a local part length check). This should be used by mail service providers at address creation to ensure email addresses meet broad compatibility requirements.
 
 ### DNS timeout and cache
 

email_validator/__init__.py

@@ -31,6 +31,7 @@ def caching_resolver(*args, **kwargs):
 ALLOW_QUOTED_LOCAL = False
 ALLOW_DOMAIN_LITERAL = False
 ALLOW_DISPLAY_NAME = False
+STRICT = False
 GLOBALLY_DELIVERABLE = True
 CHECK_DELIVERABILITY = True
 TEST_ENVIRONMENT = False

email_validator/rfc_constants.py

@@ -36,12 +36,24 @@
 QTEXT_INTL = re.compile(r"[\u0020-\u007E\u0080-\U0010FFFF]")
 
 # Length constants
+
 # RFC 3696 + errata 1003 + errata 1690 (https://www.rfc-editor.org/errata_search.php?rfc=3696&eid=1690)
-# explains the maximum length of an email address is 254 octets.
+# explains the maximum length of an email address is 254 octets based on RFC 5321 4.5.3.1.3. A
+# maximum local part length is also given at RFC 5321 4.5.3.1.1.
+#
+# But RFC 5321 4.5.3.1 says that these (and other) limits are in a sense suggestions, and longer
+# local parts have been seen in the wild. Consequntely, the local part length is only checked
+# in "strict" mode. Although the email address maximum length is also somewhat of a suggestion,
+# I don't like the idea of having no length checks performed, so I'm leaving that to always be
+# checked.
 EMAIL_MAX_LENGTH = 254
 LOCAL_PART_MAX_LENGTH = 64
+
+# Although RFC 5321 4.5.3.1.2 gives a (suggested, see above) limit of 255 octets, RFC 1035 2.3.4 also
+# imposes a length limit (255 octets). But per https://stackoverflow.com/questions/32290167/what-is-the-maximum-length-of-a-dns-name,
+# two of those octets are taken up by the optional final dot and null root label.
 DNS_LABEL_LENGTH_LIMIT = 63  # in "octets", RFC 1035 2.3.1
-DOMAIN_MAX_LENGTH = 253  # in "octets" as transmitted, RFC 1035 2.3.4 and RFC 5321 4.5.3.1.2, and see https://stackoverflow.com/questions/32290167/what-is-the-maximum-length-of-a-dns-name
+DOMAIN_MAX_LENGTH = 253  # in "octets" as transmitted
 
 # RFC 2142
 CASE_INSENSITIVE_MAILBOX_NAMES = [

email_validator/syntax.py

@@ -229,7 +229,7 @@ class LocalPartValidationResult(TypedDict):
 
 
 def validate_email_local_part(local: str, allow_smtputf8: bool = True, allow_empty_local: bool = False,
-                              quoted_local_part: bool = False) -> LocalPartValidationResult:
+                              quoted_local_part: bool = False, strict: bool = False) -> LocalPartValidationResult:
     """Validates the syntax of the local part of an email address."""
 
     if len(local) == 0:
@@ -251,7 +251,7 @@ def validate_email_local_part(local: str, allow_smtputf8: bool = True, allow_emp
     # internationalized, then the UTF-8 encoding may be longer, but
     # that may not be relevant. We will check the total address length
     # instead.
-    if len(local) > LOCAL_PART_MAX_LENGTH:
+    if strict and len(local) > LOCAL_PART_MAX_LENGTH:
         reason = get_length_reason(local, limit=LOCAL_PART_MAX_LENGTH)
         raise EmailSyntaxError(f"The email address is too long before the @-sign {reason}.")
 

email_validator/validate_email.py

@@ -22,6 +22,7 @@ def validate_email(
     allow_quoted_local: Optional[bool] = None,
     allow_domain_literal: Optional[bool] = None,
     allow_display_name: Optional[bool] = None,
+    strict: Optional[bool] = None,
     check_deliverability: Optional[bool] = None,
     test_environment: Optional[bool] = None,
     globally_deliverable: Optional[bool] = None,
@@ -36,7 +37,7 @@ def validate_email(
 
     # Fill in default values of arguments.
     from . import ALLOW_SMTPUTF8, ALLOW_EMPTY_LOCAL, ALLOW_QUOTED_LOCAL, ALLOW_DOMAIN_LITERAL, ALLOW_DISPLAY_NAME, \
-        GLOBALLY_DELIVERABLE, CHECK_DELIVERABILITY, TEST_ENVIRONMENT, DEFAULT_TIMEOUT
+        STRICT, GLOBALLY_DELIVERABLE, CHECK_DELIVERABILITY, TEST_ENVIRONMENT, DEFAULT_TIMEOUT
     if allow_smtputf8 is None:
         allow_smtputf8 = ALLOW_SMTPUTF8
     if allow_empty_local is None:
@@ -47,6 +48,8 @@ def validate_email(
         allow_domain_literal = ALLOW_DOMAIN_LITERAL
     if allow_display_name is None:
         allow_display_name = ALLOW_DISPLAY_NAME
+    if strict is None:
+        strict = STRICT
     if check_deliverability is None:
         check_deliverability = CHECK_DELIVERABILITY
     if test_environment is None:
@@ -95,7 +98,8 @@ def validate_email(
     local_part_info = validate_email_local_part(local_part,
                                                 allow_smtputf8=allow_smtputf8,
                                                 allow_empty_local=allow_empty_local,
-                                                quoted_local_part=is_quoted_local_part)
+                                                quoted_local_part=is_quoted_local_part,
+                                                strict=strict)
     ret.local_part = local_part_info["local_part"]
     ret.ascii_local_part = local_part_info["ascii_local_part"]
     ret.smtputf8 = local_part_info["smtputf8"]
@@ -118,7 +122,8 @@ def validate_email(
             validate_email_local_part(normalized_local_part,
                                       allow_smtputf8=allow_smtputf8,
                                       allow_empty_local=allow_empty_local,
-                                      quoted_local_part=is_quoted_local_part)
+                                      quoted_local_part=is_quoted_local_part,
+                                      strict=strict)
         except EmailSyntaxError as e:
             raise EmailSyntaxError("After Unicode normalization: " + str(e)) from e
         ret.local_part = normalized_local_part

tests/test_syntax.py

@@ -415,9 +415,6 @@ def test_domain_literal() -> None:
         ('test@\n', 'The part after the @-sign contains invalid characters: U+000A.'),
         ('bad"quotes"@example.com', 'The email address contains invalid characters before the @-sign: \'"\'.'),
         ('obsolete."quoted"[email protected]', 'The email address contains invalid characters before the @-sign: \'"\'.'),
-        ('11111111112222222222333333333344444444445555555555666666666677777@example.com', 'The email address is too long before the @-sign (1 character too many).'),
-        ('111111111122222222223333333333444444444455555555556666666666777777@example.com', 'The email address is too long before the @-sign (2 characters too many).'),
-        ('\uFB2C111111122222222223333333333444444444455555555556666666666777777@example.com', 'After Unicode normalization: The email address is too long before the @-sign (2 characters too many).'),
         ('me@1111111111222222222233333333334444444444555555555.6666666666777777777788888888889999999999000000000.1111111111222222222233333333334444444444555555555.6666666666777777777788888888889999999999000000000.11111111112222222222333333333344444444445555555555.com', 'The email address is too long after the @-sign (1 character too many).'),
         ('me@中1111111111222222222233333333334444444444555555555.6666666666777777777788888888889999999999000000000.1111111111222222222233333333334444444444555555555.6666666666777777777788888888889999999999000000000.1111111111222222222233333333334444444444.com', 'The email address is too long after the @-sign (1 byte too many after IDNA encoding).'),
         ('me@\uFB2C1111111111222222222233333333334444444444555555555.6666666666777777777788888888889999999999000000000.1111111111222222222233333333334444444444555555555.6666666666777777777788888888889999999999000000000.1111111111222222222233333333334444444444.com', 'The email address is too long after the @-sign (5 bytes too many after IDNA encoding).'),
@@ -467,6 +464,22 @@ def test_email_invalid_syntax(email_input: str, error_msg: str) -> None:
     assert str(exc_info.value) == error_msg
 
 
+@pytest.mark.parametrize(
+    'email_input,error_msg',
+    [
+        ('11111111112222222222333333333344444444445555555555666666666677777@example.com', 'The email address is too long before the @-sign (1 character too many).'),
+        ('111111111122222222223333333333444444444455555555556666666666777777@example.com', 'The email address is too long before the @-sign (2 characters too many).'),
+        ('\uFB2C111111122222222223333333333444444444455555555556666666666777777@example.com', 'After Unicode normalization: The email address is too long before the @-sign (2 characters too many).'),
+    ])
+def test_email_invalid_syntax_strict(email_input: str, error_msg: str) -> None:
+    # Since these all have syntax errors, deliverability
+    # checks do not arise.
+    validate_email(email_input, check_deliverability=False)  # pass without strict
+    with pytest.raises(EmailSyntaxError) as exc_info:
+        validate_email(email_input, strict=True, check_deliverability=False)
+    assert str(exc_info.value) == error_msg
+
+
 @pytest.mark.parametrize(
     'email_input',
     [
@@ -728,6 +741,11 @@ def test_pyisemail_tests(email_input: str, status: str) -> None:
         validate_email(email_input, test_environment=True)
         validate_email(email_input, allow_quoted_local=True, allow_domain_literal=True, test_environment=True)
 
+    elif status == "ISEMAIL_RFC5322_LOCAL_TOOLONG":
+        # Requires strict.
+        with pytest.raises(EmailSyntaxError):
+            validate_email(email_input, strict=True, test_environment=True)
+
     elif status == "ISEMAIL_RFC5321_QUOTEDSTRING":
         # Quoted-literal local parts are only valid with an option.
         with pytest.raises(EmailSyntaxError):