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, a=None, b=None, c=None, d=None, e=None
):
if a is not None:
self.regex = a
if b is not None:
self.message = b
if c is not None:
self.code = c
if d is not None:
self.inverse_match = d
if e is not None:
self.flags = e
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, f):
"""
Validate that the input contains (or does *not* contain, if
inverse_match is True) a match for the regular expression.
"""
g = self.regex.search(str(f))
h = g if self.inverse_match else not g
if h:
raise ValidationError(self.message, code=self.code, params={"value": f})
def __eq__(self, i):
return (
isinstance(i, RegexValidator)
and self.regex.pattern == i.regex.pattern
and self.regex.flags == i.regex.flags
and (self.message == i.message)
and (self.code == i.code)
and (self.inverse_match == i.inverse_match)
)
Run 1
The code demonstrates poor readability due to ambiguous variable names like a, b, c, d, e in __init__ and f, g, h, i in methods, obscuring intent. While the structure is logical and nesting is minimal, the one-letter parameters require readers to infer meaning from context rather than explicit naming. The code includes unnecessary 'if x is not None' checks that could be simplified using default parameter values, adding length. Action granularity is mostly one action per line, but the boolean logic line 'h = g if self.inverse_match else not g' combines operations. Reading flow is natural when docstrings exist, but documentation is sparse overall. The example is short enough to understand, but variable naming severely hampers maintainability and clarity.
Run 2
The code has severe readability issues. The RegexValidator class uses cryptic one-letter parameter names (a, b, c, d, e, f, g, h, i) which completely obscure the purpose of each argument - impossible to understand what each parameter represents without reading the entire class. The __init__ method has a confusing pattern of conditional assignments that obscures intent. The __call__ method uses meaningless variables 'g' and 'h' to store match results and boolean logic, making the validation logic difficult to trace. The class-level docstring is adequate but sparse. Action granularity is reasonable (mostly one action per line) and nesting is flat. While the structure follows standard Django validator patterns, the overall readability is compromised by non-descriptive variable names and unclear parameter naming.
Run 3
The code is heavily obfuscated with meaningless variable names (a, b, c, d, e, f, g, h, i), which severely impairs clarity of intent and reading flow. While the structure is logical and flat, the renaming of standard Django parameters (regex, message, code, inverse_match, flags) to single letters makes the constructor and methods confusing. The __call__ method uses unclear variables (g, h) instead of descriptive names like 'match' and 'should_raise'. Action granularity is reasonable, but overall readability is poor because readers must infer meaning from context. The code preserves Django's architecture but sacrifices maintainability through non-descriptive naming.
Run 1
Code Structure: The class is logically organized into defaults, initialization, validation, and equality comparison. Nesting: Shallow conditionals keep the code easy to navigate. Clarity of intent: Descriptive attributes, the validation docstring, and clear error messages explain the purpose, but single-letter parameters and local variables obscure their roles, especially in initialization and inverse-match logic. Code length: The implementation is reasonably concise, although numerous unused imports add clutter and the split initializer signature is unnecessary. Action granularity: Statements generally perform one action per line, and the equality expression is clearly separated into individual checks. Reading flow: Method ordering and consistent formatting support a natural progression, but readers must repeatedly map anonymous variables to meaningful attributes.
Run 2
Code Structure: The class is logically organized into configuration, initialization, validation, and equality methods, though several imports are unused. Nesting: Shallow conditionals and no nested loops make control flow easy to follow. Clarity of intent: Descriptive class attributes and the validation docstring clarify purpose, but single-letter parameters and variables obscure meanings and require tracing assignments. Code length: Mostly concise, although the multiline constructor signature and unused imports add unnecessary clutter. Action granularity: Statements generally perform one action per line; the compound equality expression is sensibly split across lines. Reading flow: Method ordering is natural and formatting is consistent, but cryptic names and the inverse-match conditional slow comprehension.
Run 3
Code Structure: The class logically separates configuration, validation, and equality checks, though unused imports add clutter. Nesting: Shallow conditionals keep control flow easy to follow. Clarity of intent: Descriptive class attributes and the validation docstring explain the purpose, but single-letter parameters and variables obscure their roles, especially in initialization and inverse matching. Code length: The implementation is reasonably concise, although excess imports and the unnecessarily split initializer signature reduce compactness. Action granularity: Statements generally perform one action per line, with no compressed multi-statement logic. Reading flow: Methods follow a natural lifecycle, and formatting is consistent overall; however, readers must repeatedly map anonymous names to meaningful attributes, interrupting comprehension.