Source code
import operator
import re
from contextlib import contextmanager
from re import Pattern
from ._config import get_run_validators, set_run_validators
from ._make import _AndValidator, and_, attrib, attrs
from .converters import default_if_none
from .exceptions import NotCallableError
@attrs(repr=False, frozen=True, slots=True)
class _MatchesReValidator:
pattern = attrib()
match_func = attrib()
def __call__(self, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not self.match_func(value):
msg = f"'{attr.name}' must match regex {self.pattern.pattern!r} ({value!r} doesn't)"
raise ValueError(
msg, attr,
self.pattern,
value,
)
def __repr__(self):
return f"<matches_re validator for pattern {self.pattern!r}>"
Run 1
The code is generally readable with clear intent and good structure. The class definition is clean, and the use of attributes/frozen slots is standard. The main issue is the ValueError raising with multiple arguments and odd indentation, which obscures the error structure. Nesting is shallow, and action granularity is mostly one per line. However, the 'misaligned' arguments in the raise statement disrupt reading flow. Imports are somewhat verbose but acceptable. Overall, it's understandable but has minor formatting and clarity issues.
Run 2
The code is moderately readable but has some issues. The structure is logical with a single validator class, but the __call__ method contains an awkward multi-line raise statement with oddly aligned arguments (attr, self.pattern, value) that appears misindented. Nesting is minimal and flat, which is good. Intent is mostly clear—validating regex matches—but the unused imports (operator, re, Pattern, contextmanager, get_run_validators, etc.) create ambiguity about dependencies. Code length is concise but could benefit from minor formatting cleanup. Action granularity is acceptable; each line performs one logical action. Reading flow is natural for the class definition, but the raise statement's argument alignment disrupts visual rhythm. The docstring helps explain the class pattern choice. Overall, functional but could be improved by removing unused imports and reformatting the raise statement for better visual consistency.
Run 3
The code has a clear overall purpose—a regex validator class—and uses modern attrs features like frozen and slots, which aid clarity. However, readability suffers in several ways. The import block mixes standard library, typing, and internal modules without grouping, slightly obscuring intent. The class name is descriptive but long. The main method `__call__` constructs a multi-line error message and raises ValueError with inconsistent indentation and alignment in the argument list, which harms reading flow and action granularity. The use of a callable class is explained but the docstring is minimal. The `__repr__` is concise. Overall, the code is understandable but would benefit from cleaner exception construction, better import organization, and more consistent formatting to improve readability.
Run 1
Code Structure: The validator is logically organized into attributes, validation behavior, and representation, though several unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Class and attribute names clearly convey regex validation, but the __call__ docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, with little unnecessary logic. Action granularity: Most lines perform one action, although placing msg and attr on the same argument line with excessive spacing hurts readability. Reading flow: The sequence is natural, but missing blank lines between imports, the class declaration, attributes, and methods makes the layout cramped.
Run 2
Code Structure: The small validator class logically separates validation from representation, but unused imports clutter the snippet. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Class and attribute names clearly convey regex validation, although the __call__ docstring explains the callable-class design rather than the method's behavior, and inst is unused. Code length: The implementation is concise, with little unnecessary logic. Action granularity: Most lines contain one action, but placing msg and attr on the same line in the exception arguments disrupts consistency. Reading flow: Validation followed by __repr__ is natural, but missing blank lines between imports, the class, attributes, and methods, plus irregular spacing in the ValueError call, reduce readability.
Run 3
Code Structure: The validator class is logically organized, but numerous unused imports and missing blank lines between sections add clutter. Nesting: A single conditional keeps the implementation shallow and easy to follow. Clarity of intent: Class and attribute names clearly convey regex validation; however, the __call__ docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, though unused imports unnecessarily lengthen the snippet. Action granularity: Statements generally perform one action each, but placing msg and attr on the same line in the exception arguments reduces visual clarity. Reading flow: Validation followed by an error and a custom representation is natural, but inconsistent spacing and the long error-message line interrupt scanning.