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):
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 well-structured and readable. It uses clear class and method definitions with logical ordering. The 'RegexValidator' class has clear attributes and an '__init__' method that sets parameters with sensible defaults. Nesting is minimal, with only one level of indentation in the '__call__' and '__eq__' methods. Intent is evident from class and method names, and docstrings or comments are absent but not necessary due to clarity. Code length is concise, avoiding redundancy. Action granularity is appropriate, with each line performing a single clear action, except for the combined boolean assignment in '__call__', which is still understandable. Reading flow is natural, from imports to class definition to methods. Minor deductions for the slightly complex 'invalid_input' line and lack of type hints, but overall the code is highly readable.
Run 2
The code is generally readable and well-structured. It has a clear class definition with logical organization of constants and methods. Nesting is minimal, with no deep indentation levels. The intent of the class is clear as a regex validation utility. The __init__ method handles optional parameters cleanly, though it could be slightly more concise using a dictionary for parameter assignment. The __call__ method is straightforward with clear variable naming. The __eq__ method is readable but the boolean comparison chain is a bit lengthy. Overall, the code follows Django conventions and is maintainable, but loses points for some repetitive parameter handling and slightly verbose comparison logic.
Run 3
The code is highly readable with clear class structure, minimal nesting, and explicit intent. Each method has a single responsibility and follows Django conventions. The __init__ parameter handling is concise with predictable defaults and logical validation. The __call__ method uses a flat, two-line conditional approach where the inverse_match logic is clearly expressed. The __eq__ method is straightforward despite its length, with each comparison on separate lines aiding readability. Minor deductions: the blank line after the __call__ signature is an unnecessary gap, and the __eq__ method could be slightly more concise. Overall, the code demonstrates excellent structure, clear naming, and natural reading flow without unnecessary complexity.
Run 1
Code Structure: The class logically groups defaults, initialization, validation, and equality comparison; several unused imports add clutter. Nesting: Shallow conditionals keep the code easy to follow. Clarity of intent: Descriptive names and explicit error messages make the validator's purpose clear, although inverse-match logic requires slight interpretation. Code length: Compact overall, with reasonable repetition for optional attribute overrides. Action granularity: Each statement performs one clear action, and multiline expressions are sensibly formatted. Reading flow: Methods follow a natural progression, though the stray blank line in __call__ and unnecessary parentheses in parts of __eq__ slightly reduce polish.
Run 2
Code Structure: The 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 conventional validator methods make the purpose clear; the inverse-match expression requires a little extra interpretation. Code length: The implementation is concise overall, although initialization repeats similar checks and the import list is unnecessarily long for this snippet. Action granularity: Statements generally perform one action per line, and multiline expressions are formatted clearly. Reading flow: Methods follow a natural sequence, with consistent indentation and readable line wrapping; a stray blank line and redundant comparison parentheses slightly reduce polish.
Run 3
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 the code easy to follow. Clarity of intent: Descriptive names clearly communicate configurable regex validation; the inverse-match expression requires a little extra thought. Code length: Concise overall, with some repetitive but straightforward initialization checks. Action granularity: Each statement performs a single clear action, and multiline expressions are formatted appropriately. Reading flow: Methods follow a natural sequence, and consistent formatting supports scanning. Missing explanatory documentation and minor whitespace issues slightly reduce readability.