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):
raise ValueError(
(f"'{attr.name}' must match regex {self.pattern.pattern!r} ({value!r} doesn't)"),
attr,
self.pattern,
value,
)
def __repr__(self):
return f"<matches_re validator for pattern {self.pattern!r}>"
Run 1
The code is highly readable with clear structure and intent. It uses a frozen, slotted attrs class for an immutable validator, which is logical and concise. The `__call__` method is flat, with a single conditional and a clear error message. Naming is explicit (`_MatchesReValidator`, `match_func`, `pattern`). Action granularity is appropriate—each significant step is on its own line. The only minor deductions are for an unnecessary blank line inside the `if` block and the slightly verbose f-string, which could be clearer with line breaks. Overall, the reading flow is natural and the logic is easy to follow.
Run 2
The code is generally readable with clear structure and purpose. It uses a frozen attrs class as a validator, and the docstring explains the design choice. Naming is descriptive (_MatchesReValidator, match_func). The __call__ method is flat and concise, with one primary action plus error construction. The __repr__ is clear. Minor deductions: an unnecessary blank line inside __call__, and the error message f-string is slightly dense. The import block is somewhat cluttered with unused imports (operator, re, Pattern, contextmanager, get_run_validators, etc.), which reduces clarity. Overall, intent is understandable and flow is natural, but tidier imports and minor formatting would improve readability.
Run 3
The code is generally readable with a clear class structure, minimal nesting, and good use of type hints and docstrings. It follows logical organization with a single responsibility for the class. The blank line after the conditional is slightly awkward, and the error message formatting is dense but acceptable. The use of attrs decorators keeps the code concise. However, the purpose of match_func and pattern attributes could be clearer with more descriptive names or type annotations. The repr method is straightforward. Overall, the code demonstrates good readability with minor improvements possible in formatting and naming clarity.
Run 1
Code Structure: The validator is logically organized into attributes, validation behavior, and representation, although numerous unused imports add clutter. Nesting: A single conditional keeps nesting shallow. Clarity of intent: Descriptive class and attribute names make regex validation clear, but the __call__ docstring explains the callable-class design rather than validation behavior. Code length: The implementation is concise, though redundant parentheses around the error message and an empty line before the raise are unnecessary. Action granularity: Each statement performs one clear action, and the exception arguments are neatly separated. Reading flow: Methods follow a natural order, but import clutter, limited spacing before the class, and the stray blank line slightly interrupt readability.
Run 2
Code Structure: The validator class is logically organized, with attributes, validation behavior, and representation clearly separated, though several imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: Class and attribute names make regex validation clear, but the __call__ docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise; redundant parentheses around the error message and an extra blank line add minor clutter. Action granularity: Each statement performs one clear action, and the exception arguments are laid out separately. Reading flow: The progression from configuration to validation to representation is natural, although the blank line before raise slightly interrupts it.
Run 3
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 shallow and easy to follow. Clarity of intent: Class and attribute names clearly communicate regex validation, and the error message is informative; however, the __call__ docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, but unnecessary parentheses around the error-message f-string and an extra blank line reduce polish. Action granularity: Each statement performs one clear action, and the multiline exception arguments are readable. Reading flow: The progression from state to validation to representation is natural, with minor distractions from import clutter and inconsistent spacing.