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 and readable. It follows a clear logical organization, with a focused class definition and minimal nesting. The intent is immediately understandable: a validator that checks if a value matches a regular expression. Variable names are descriptive ('pattern', 'match_func', 'inst', 'attr', 'value'). The error message is informative and includes relevant context. The __repr__ method clearly summarizes the validator. The only minor deductions are for slight verbosity in the docstring (attribution is implicit) and the somewhat compressed conditional raise, although it remains clear. Overall, the code is concise, easy to follow, and maintains a natural reading flow.
Run 2
The code is well-structured and highly readable. It uses a clear class-based approach with attrs, which keeps the definition concise. Nesting is minimal, with only one level inside the __call__ method. The purpose is explicit: validate a string against a regex pattern. Lines are concise and each line generally performs one action. The reading flow is natural—imports, class definition, then method logic. The only minor deductions are due to the slightly dense error message construction and the reliance on external attrs features, which may require familiarity with the library. Overall, it is clean, maintainable, and purposeful.
Run 3
The code is well-structured and readable. It uses a clear class-based approach for a regex validator with the attrs library, keeping the structure logical and flat. Nesting is minimal, limited to a single conditional inside the __call__ method. The intent is explicit: validate that a value matches a regex pattern and raise a descriptive error if not. The code is concise, avoiding unnecessary verbosity, though the error message construction is a bit long but justifiably informative. Each line performs a single logical action, and the reading flow is natural — imports, class definition, logic, and repr. Minor deductions stem from slightly dense imports and the use of decorators that assume familiarity with attrs, which may slightly reduce clarity for less experienced readers.
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 control flow shallow and easy to follow. Clarity of intent: Descriptive class and attribute names clearly convey regex validation; the __call__ docstring explains the callable-class design rather than the method’s behavior. Code length: The implementation is concise, although the multiline exception construction could be more compact. Action granularity: Each statement performs one clear action, with message construction separated from raising the exception. Reading flow: Imports, class configuration, attributes, and methods follow a conventional order. Framework-specific decorators and attribute declarations require some familiarity, but overall readability is high.
Run 2
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 a detailed 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 slightly verbose. Action granularity: Each statement performs one clear action. Reading flow: The progression from configuration to validation to representation is natural, with minor friction from framework-specific decorators and the long error-message line.
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 names and the error message clearly communicate regex validation; 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 slightly verbose. Action granularity: Each statement performs one clear action. Reading flow: Attributes followed by __call__ and __repr__ create a natural progression; minimal spacing between imports and the class slightly reduces visual separation.