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 well-structured with clear separation of imports, a single cohesive class, and a focused purpose. Nesting is minimal, with only one conditional inside a method, making the logic easy to follow. Intent is unmistakable: a validator that enforces regex matching on attribute values. The class is concise, with no redundant or verbose sections. Action granularity is appropriate—most lines perform a single logical operation, though the f-string and `raise ValueError` combine multiple pieces of data, which slightly reduces readability. Reading flow is natural: imports, class definition, method logic, and representation follow a logical progression. Minor deductions come from the multi-line `raise` with mixed data and the lack of type hints, which could enhance clarity. Overall, this is highly readable, maintainable code.
Run 2
The code is highly readable due to its clear structure and concise implementation. It uses a frozen, slotted attrs class for immutability, and the validator method is flat with minimal nesting, handling a single validation action. Intent is explicit: validate a string against a regex pattern and raise a descriptive error if it fails. The `__call__` method has a single responsibility and uses clear variable names. The `__repr__` improves debuggability. Minor points: the docstring inside `__call__` is a bit sparse, and the error message formatting is slightly dense, but overall the reading flow is natural and the code is well-organized.
Run 3
The code is well-structured with a clear class-based validator implementation. It uses decorators effectively (@attrs) to reduce boilerplate. Nesting is minimal—only one level inside the __call__ method. Intent is explicit: the class name, attribute names, and error message clearly convey validation behavior. Code length is appropriate, avoiding unnecessary verbosity while maintaining clarity. Action granularity is good; each logical step (checking match, building message, raising exception) is on separate lines. Reading flow is natural: imports, class definition, attributes, core logic, and repr follow a logical order. Minor deductions: the docstring could be more informative, and the conditional check could be slightly clearer with a variable named 'is_match' instead of inverting the check.
Run 1
Code Structure: The small validator class is logically organized, with attributes, validation behavior, and representation clearly separated; several unused imports add clutter. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: Descriptive class and attribute names, a helpful docstring, and an informative error message make the purpose clear, although the docstring explains the callable-class design rather than validation behavior. Code length: The implementation is concise, but the unused imports and expanded exception arguments add some unnecessary bulk. Action granularity: Each statement performs one clear action. Reading flow: The progression from stored configuration to validation and representation is natural, with consistent formatting.
Run 2
Code Structure: Imports, class attributes, validation behavior, and representation are logically organized, although several imports are unused in this snippet. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: Descriptive names and an informative error message make regex validation clear; the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, though the multiline exception construction is somewhat verbose. Action granularity: Each statement performs one clear action, with message creation separated from raising the exception. Reading flow: The class reads naturally from configuration through validation to representation, with decorators adding a modest dependency on framework knowledge.
Run 3
Code Structure: The validator is logically organized into attributes, validation behavior, and representation, though several imports are unused in this snippet. Nesting: A single conditional keeps control flow shallow. Clarity of intent: Descriptive class and attribute names, together with the error message, make regex validation clear; the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although the multiline exception construction is somewhat verbose. Action granularity: Each statement performs one clear action. Reading flow: The sequence is natural and easy to follow, with minor readability costs from framework-specific decorators and the long error-message line.