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, ins, att, val):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if not self.match_func(val):
msg2 = f"'{att.name}' must match regex {self.pattern.pattern!r} ({val!r} doesn't)"
raise ValueError(
msg2,
att,
self.pattern,
val,
)
def __repr__(self):
return f"<matches_re validator for pattern {self.pattern!r}>"
Run 1
The code is highly readable with a clear, logical structure. The class is small and focused, with a single responsibility (regex validation). Nesting is minimal—only one conditional inside the __call__ method. The intent is explicit through descriptive naming (e.g., _MatchesReValidator, match_func, pattern). Code length is concise and appropriate for the functionality. Each statement occupies its own line, and the error message construction is clear. The reading flow is natural: imports at the top, class definition, then its methods. Minor deduction: the variable name 'msg2' and 'ins' parameter are slightly ambiguous, and the docstring placement inside __call__ is unconventional, but these are minor readability issues.
Run 2
The code is well-structured and readable. It uses a frozen, slotted attrs class with a clear single responsibility: validating regex matches. The __call__ method is flat, with only one level of nesting in the conditional check. Variable names are mostly clear ('pattern', 'match_func', 'att', 'val'), though 'ins' and 'msg2' are slightly ambiguous. The error message construction is concise but could be more explicit. The class is short and focused, with one action per line in the main method. The repr override is simple and informative. Overall, the code demonstrates good action granularity, logical organization, and clarity of intent, with minor room for improvement in variable naming and error message clarity.
Run 3
The code is generally clean and readable. It uses a frozen attrs class with clear attributes and a single-purpose __call__ method, which keeps structure logical and intent obvious. Nesting is minimal, and action granularity is mostly one action per line. However, naming is slightly inconsistent: the error message variable is 'msg2' despite no 'msg1' existing, which is ambiguous. The regex pattern is accessed via self.pattern.pattern, which could confuse readers unfamiliar with compiled pattern internals. The __repr__ is concise but slightly dense. Overall, it is well-structured but has minor clarity issues that prevent a higher score.
Run 1
Code Structure: The validator class is logically organized, with attributes, validation behavior, and representation clearly separated; however, numerous unused imports distract from the small example. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Class and attribute names clearly convey regex validation, but abbreviated parameters and the name 'msg2' reduce clarity; the call-method docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, though unused imports and the expanded exception arguments add some visual overhead. Action granularity: Each statement performs one clear action. Reading flow: The progression from configuration to validation to representation is natural, with only minor naming and formatting distractions.
Run 2
Code Structure: The validator is logically organized into attributes, validation behavior, and representation, though numerous unused imports clutter this snippet. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: Class and attribute names clearly convey regex validation, but abbreviated parameters (ins, att, val), the name msg2, and a docstring focused on representation rather than validation reduce clarity. Code length: The implementation is concise overall; the multiline exception construction is somewhat verbose but readable. Action granularity: Each statement performs a single clear action. Reading flow: Attributes followed by __call__ and __repr__ provide a natural progression, although additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: The small validator class logically separates attributes, validation, and representation, though numerous unused imports distract from its organization. Nesting: A single conditional keeps control flow shallow and easy to follow. Clarity of intent: The class name, regex error message, and method behavior clearly convey validation, but abbreviated parameters (ins, att, val), the name msg2, and a docstring focused on representation weaken clarity. Code length: The implementation is concise, although unused imports and the expanded exception argument list add minor clutter. Action granularity: Each statement performs one clear action, with message construction separated from raising the exception. Reading flow: Attributes precede behavior naturally, and formatting is consistent; additional spacing between imports and the class would improve visual separation.