Source code
import ipaddress
import math
import re
from pathlib import Path
from urllib.parse import urlsplit
from django.core.exceptions import ValidationError
from django.utils.deconstruct import deconstructible
from django.utils.http import MAX_URL_LENGTH
from django.utils.ipv6 import is_valid_ipv6_address
from django.utils.regex_helper import _lazy_re_compile
from django.utils.translation import gettext_lazy as _
from django.utils.translation import ngettext_lazy
@deconstructible
class RegexValidator:
regex = ""
message = _("Enter a valid value.")
code = "invalid"
inverse_match = False
flags = 0
def __init__(
self, regex=None, message=None, code=None, inverse_match=None, flags=None
):
if regex is not None:
self.regex = regex
if message is not None:
self.message = message
if code is not None:
self.code = code
if inverse_match is not None:
self.inverse_match = inverse_match
if flags is not None:
self.flags = flags
if self.flags and not isinstance(self.regex, str):
raise TypeError(
"If the flags are set, regex must be a regular expression string."
)
self.regex = _lazy_re_compile(self.regex, self.flags)
def __call__(self, value):
"""
Validate that the input contains (or does *not* contain, if
inverse_match is True) a match for the regular expression.
"""
regex_matches = self.regex.search(str(value))
invalid_input = regex_matches if self.inverse_match else not regex_matches
if invalid_input:
raise ValidationError(self.message, code=self.code, params={"value": value})
def __eq__(self, other):
return (
isinstance(other, RegexValidator)
and self.regex.pattern == other.regex.pattern
and self.regex.flags == other.regex.flags
and (self.message == other.message)
and (self.code == other.code)
and (self.inverse_match == other.inverse_match)
)
Run 1
The code is generally well-structured with clear intent, flat nesting, and good action granularity. Each validation step is separated logically. However, minor issues prevent a higher score: variable names like 'invalid_input' are slightly ambiguous, and the __init__ method uses repetitive conditional assignments that could be simplified. The docstring helps clarify purpose, and line length is reasonable. Overall, it maintains good readability patterns with only minor opportunities for improvement.
Run 2
The code demonstrates good readability through clear structure and logical organization. The RegexValidator class is well-organized with class attributes defined at the top and methods properly separated. Nesting is minimal with only one level in the __init__ method and no deep conditional chains. Intent is clear - this is a Django-style validator that compiles and applies regex patterns. The code length is appropriate, not overly verbose or overly compressed. Action granularity is generally good with one logical operation per line, though the __eq__ method chains multiple comparisons on single lines. Reading flow is natural - imports, class definition, attributes, initialization, validation logic, then equality comparison. The docstring in __call__ adds helpful context. Minor deductions: the repeated if-statements in __init__ could use a cleaner pattern, and the __eq__ method's line breaks could be more consistent. Variable naming like 'invalid_input' clearly expresses intent.
Run 3
The code is well-structured with clear imports, a clean class definition, and logical method organization. The constructor is flat and readable, and __call__ uses a concise two-line validation flow. The __eq__ method is also clear. Minor deductions: the constructor has five optional params and repetitive if statements, which slightly reduces conciseness; the comment in __call__ is helpful but adds length. Overall, intent is clear and the flow is natural.
Run 1
Code Structure: The class is logically organized into defaults, initialization, validation, and equality comparison. Nesting: Shallow conditionals keep execution easy to follow. Clarity of intent: Descriptive names, a useful validation docstring, and explicit error messages clearly communicate purpose; the inverse-match expression requires slight extra attention. Code length: The implementation is concise, though several imports are unused in this snippet and initialization repeats similar assignments. Action granularity: Each statement performs one clear action, with long expressions appropriately split across lines. Reading flow: Methods follow a natural progression and consistent formatting supports scanning, although additional spacing between imports and the class would improve separation.
Run 2
Code Structure: The class is logically organized into defaults, initialization, validation, and equality comparison, though several imports are unused in this snippet. Nesting: Shallow conditionals keep control flow easy to follow. Clarity of intent: Descriptive names and the validation docstring make the purpose clear; the inverse-match expression requires a little extra thought. Code length: Concise overall, with some repetitive initialization checks that remain straightforward and readable. Action granularity: Each statement performs a focused action, with multiline expressions formatted clearly. Reading flow: Methods follow a natural progression, and consistent formatting supports scanning. Minor drawbacks include the unused imports, missing separation between import groups, and unnecessary parentheses around some equality comparisons.
Run 3
Code Structure: The validator class is logically organized into defaults, initialization, validation, and equality comparison, though several unused imports add clutter. Nesting: Control flow is shallow, with straightforward conditionals and no deeply nested blocks. Clarity of intent: Descriptive names and the validation docstring clearly communicate purpose; inverse-match logic requires slight extra attention. Code length: The implementation is concise overall, although repetitive initialization checks and unused imports slightly reduce economy. Action granularity: Statements generally perform one action per line, and longer expressions are formatted cleanly across lines. Reading flow: Methods follow a natural progression, with consistent formatting and readable error handling. Minor spacing improvements between imports and the class would improve visual separation.