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 _MinLengthValidator:
min_length = attrib()
def __call__(self, a, b, c):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if len(c) < self.min_length:
d = f"Length of '{b.name}' must be >= {self.min_length}: {len(c)}"
raise ValueError(d)
def __repr__(self):
return f"<min_len validator for {self.min_length}>"
Run 1
The code is highly readable. It is well-structured as a small, focused validator class using attrs. Nesting is minimal (only one conditional inside __call__). Intent is clear from the class and method names, and the docstring clarifies the design choice of using a callable class. Code length is concise. Action granularity is reasonable: the length check, message formatting, and exception raising are separated appropriately, though some minor consolidation might be possible. Reading flow is natural and logical. Minor deductions: variable names like 'a', 'b', 'c', and 'd' are uninformative, and the flow steps in __call__ could be slightly more explicit. Overall, it is very readable.
Run 2
The code is generally clear and well-structured. The use of a frozen dataclass-like validator with a callable class is logical. Naming is partially unclear (a, b, c in __call__), but the docstring explains intent. Nesting is minimal, and action granularity is one per line. Length is concise. Reading flow is decent, but parameter names reduce immediate clarity.
Run 3
The code is generally readable but has some clarity issues. The structure is logical, importing only what is needed, and the class is cleanly defined with a clear purpose. Nesting is minimal, with only one conditional inside the __call__ method. The code length is appropriate for the functionality. However, the parameter names 'a', 'b', and 'c' in __call__ are ambiguous and hurt readability; they should be descriptive like 'instance', 'attribute', and 'value'. Additionally, the variable 'd' for the error message is not descriptive. The __repr__ method is concise but the string format is slightly inconsistent with typical naming. Reading flow is natural, but the placeholder names and generic variable 'd' disrupt understanding. Action granularity is fine, with one main action per line. Overall, the code is understandable but would benefit from clearer variable naming.
Run 1
Code Structure: The validator class is logically organized, with configuration, validation, and representation separated, though numerous unused imports clutter the snippet. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: The class name, min_length attribute, and error message clearly express minimum-length validation, but parameter names a, b, c and temporary variable d obscure their roles. The docstring explains the callable-class design rather than the method's validation behavior. Code length: The implementation is concise, aside from unused imports. Action granularity: Each statement performs one clear action. Reading flow: The progression from stored constraint to validation and representation is natural, although descriptive parameter names and cleaner imports would improve readability.
Run 2
Code Structure: The validator class logically groups its configuration, validation behavior, and representation, though numerous unused imports add clutter. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: The class name, min_length attribute, and error message clearly convey minimum-length validation, but parameters a, b, c and variable d are cryptic; the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although the unused imports unnecessarily lengthen the snippet. Action granularity: Each statement performs one clear action, with error construction and raising separated. Reading flow: Configuration, validation, and representation appear in a natural order, but opaque variable names and framework-specific decorators slightly interrupt comprehension.
Run 3
Code Structure: Imports and a focused validator class are logically organized, although several imports are unused in this snippet. Nesting: Only a single conditional keeps the code easy to follow. Clarity of intent: The class name, min_length attribute, and error message clearly communicate minimum-length validation, but parameters a, b, c and temporary variable d are cryptic. The docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise without unnecessary complexity. Action granularity: Each line performs one clear action. Reading flow: Validation followed by a custom representation is natural, though descriptive parameter names and better spacing between imports and the class would improve readability.