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 readable. It clearly defines a frozen attrs class with a single responsibility: regex validation. The __call__ method has a flat structure with minimal nesting, and the error message construction is clear. The code is concise without unnecessary verbosity. Each line focuses on a single action, enhancing readability. The reading flow is natural, with logical imports and a coherent class definition. Minor deductions: using 'inst' as an unused parameter is slightly ambiguous, and the multiline ValueError call adds some visual complexity. Overall, it's straightforward and maintainable.
Run 3
The code is highly readable due to its logical structure, flat nesting, and clear intent. The use of a frozen, slotted attrs class with a clear name (_MatchesReValidator) immediately communicates its purpose. The __call__ method is concise: it performs a single validation check, constructs a clear error message, and raises a ValueError with relevant context. Action granularity is mostly one action per line, especially in the error-raising block. The __repr__ method aids debugging. Minor deductions: the import of operator and re is unused, and the use of a contextmanager import is irrelevant. Also, the pattern is passed to the exception but not clearly explained in the code itself. Overall, the code follows idiomatic Python practices and reads naturally.
Run 1
Code Structure: The small validator class logically groups its state, validation behavior, and representation, though several imports are unused in this snippet. Nesting: A single conditional keeps control flow shallow. Clarity of intent: Class and method names, the regex check, and the descriptive error message communicate the purpose clearly; however, the call-method docstring explains the class design rather than validation behavior. Code length: The implementation is concise, although the multiline exception construction is somewhat verbose. Action granularity: Each statement performs a distinct action, separating message construction from raising the exception. Reading flow: Imports, class attributes, validation, and representation follow a natural sequence, with minor spacing inconsistencies and unused imports adding visual noise.
Run 2
Code Structure: The validator class is logically organized, with attributes followed by validation and representation methods; several unused imports add clutter. Nesting: A single conditional keeps control flow shallow and easy to follow. Clarity of intent: Descriptive names and an informative error message make regex validation clear, though the __call__ docstring explains the 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, with message construction separated from raising the exception. Reading flow: Execution flows naturally from checking the value to reporting failure, followed by the representation method; additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: The validator is logically organized, with attributes, validation behavior, and representation clearly separated; several unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive class and attribute names make regex validation clear, although the __call__ docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, with slightly verbose formatting for the exception arguments. Action granularity: Each statement performs one clear action. Reading flow: The progression from configuration to validation to representation is natural, though a blank line between imports and the decorated class would improve visual separation.