File size: 4,621 Bytes
bf57148 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | # Email Validation
**Task:** "Write me a Python function that validates email addresses."
Verbatim model output from a benchmark run, Claude Haiku 4.5, no-skill arm vs ponytail arm, temperature 1, source `benchmarks/output.json`. Reproduce: `npx promptfoo@latest eval -c benchmarks/promptfooconfig.yaml`.
## Without Ponytail, 75 lines of code
# Email Validation Function
Here's a practical Python function that validates email addresses:
```python
import re
def validate_email(email: str) -> bool:
"""
Validates an email address using a regular expression.
Args:
email (str): The email address to validate
Returns:
bool: True if valid, False otherwise
"""
# Regular expression pattern for email validation
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
return re.match(pattern, email) is not None
# Test cases
if __name__ == "__main__":
test_emails = [
"user@example.com", # Valid
"john.doe@company.co.uk", # Valid
"test+tag@domain.org", # Valid
"invalid.email@", # Invalid
"missing@domain", # Invalid
"@nodomain.com", # Invalid
"spaces in@email.com", # Invalid
"user@domain..com", # Invalid (double dot)
]
for email in test_emails:
result = validate_email(email)
print(f"{email:<30} -> {result}")
```
## More Robust Version (with additional checks)
```python
import re
def validate_email_advanced(email: str) -> tuple[bool, str]:
"""
Advanced email validation with detailed feedback.
Args:
email (str): The email address to validate
Returns:
tuple: (is_valid, message)
"""
# Basic checks
if not email or not isinstance(email, str):
return False, "Email must be a non-empty string"
email = email.strip()
if len(email) > 254:
return False, "Email is too long (max 254 characters)"
# Regular expression pattern
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
if not re.match(pattern, email):
return False, "Email format is invalid"
# Additional checks
local_part, domain = email.rsplit('@', 1)
if len(local_part) > 64:
return False, "Local part is too long (max 64 characters)"
if local_part.startswith('.') or local_part.endswith('.'):
return False, "Local part cannot start or end with a dot"
if '..' in email:
return False, "Email cannot contain consecutive dots"
return True, "Email is valid"
# Test the advanced version
if __name__ == "__main__":
test_emails = [
"user@example.com",
"invalid..email@domain.com",
".invalid@domain.com",
"user@domain",
]
for email in test_emails:
is_valid, message = validate_email_advanced(email)
print(f"{email:<35} -> {is_valid:5} ({message})")
```
## Using a Third-Party Library (Recommended for Production)
```python
from email_validator import validate_email, EmailNotValidError
def validate_email_production(email: str) -> bool:
"""
Validates email using the email_validator library.
More reliable for production use.
Install with: pip install email-validator
"""
try:
# Validate and normalize the email
valid = validate_email(email)
return True
except EmailNotValidError:
return False
# Usage
if __name__ == "__main__":
print(validate_email_production("user@example.com")) # True
print(validate_email_production("invalid@")) # False
```
## Comparison
| Method | Pros | Cons |
|--------|------|------|
| **Regex (Simple)** | Fast, no dependencies | Limited validation |
| **Regex (Advanced)** | More thorough | Still not RFC-compliant |
| **email-validator** | RFC-compliant, reliable | External dependency |
**Recommendation**: Use the `email-validator` library for production applications, as it properly handles RFC 5321/5322 standards. Use the simple regex version for quick scripts or when you want to avoid dependencies.
## With Ponytail, 3 lines of code
```python
import re
def is_valid_email(email: str) -> bool:
return bool(re.match(r'^[^@]+@[^@]+\.[^@]+$', email))
```
Skipped: RFC 5322 parser, DNS MX lookup, confirmation email. Add when you actually need to reject `user+tag@sub.domain.co.uk` or catch typos, until then, this catches 99% of "oops I fat-fingered it" cases.
**75 → 3 lines of code**, same model, same prompt.
|