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, data, mode, limit):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if len(limit) < self.min_length:
key = f"Length of '{mode.name}' must be >= {self.min_length}: {len(limit)}"
raise ValueError(key)
def __repr__(self):
return f"<min_len validator for {self.min_length}>"
Run 1
The code is well-structured and clear. It uses a single-purpose class with a focused __call__ method, keeping nesting flat and action granularity appropriate. Imports are clean, the docstring explains the callable-class choice, and the error message is explicit. Minor deduction: the import list includes unused names (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, _AndValidator, and_, default_if_none, NotCallableError), which slightly reduces clarity. Overall, highly readable.
Run 2
The code is generally readable with a clear structure: imports are organized, the class is well-defined with a clear purpose, and the validator logic is straightforward. The nesting is minimal, and the action granularity is appropriate. However, there are areas for improvement: unused imports (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, and_, attrib, attrs, default_if_none, NotCallableError) and unclear naming ('mode' and 'limit' are ambiguous), which slightly reduce clarity. The docstring is helpful but could be more descriptive. Overall, it's concise and maintainable but could benefit from cleanup.
Run 3
The code demonstrates good readability. The class structure is logical, with a clear `__call__` method performing validation and a custom `__repr__` for debugging. Nesting is minimal, with only one conditional block. Intent is clear: enforce a minimum length constraint. Code length is concise, and each line typically performs a single action. The reading flow is natural, starting with imports, followed by the class definition, the core validation logic, and finishing with representation. However, minor points prevent a top score: the `mode` parameter in `__call__` is used only for error message context, which might be slightly ambiguous without additional documentation, and the error message construction combines multiple operations into one f-string, slightly reducing line-level granularity.
Run 1
Code Structure: Imports and a small validator class are logically organized, though several imports appear unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, min_length attribute, and error message clearly express minimum-length validation, but parameter names data, mode, and limit are ambiguous; data is unused, and the docstring explains the callable-class design rather than validation behavior. Code length: The implementation is concise, with little unnecessary code beyond the unused imports. Action granularity: Each line performs one clear action, separating message construction from raising the exception. Reading flow: The attribute, validation method, and representation method follow a natural order, although clearer parameter names and more spacing between imports and the class would improve readability.
Run 2
Code Structure: The validator is logically organized into a field declaration, validation method, and representation method, although numerous unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: The class name and comparison clearly communicate minimum-length validation, but parameter names such as 'mode' and 'limit' are misleading, 'data' is unused, and the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, though the imports are excessive for this snippet. Action granularity: Each line performs one clear action, with error-message construction separated from raising the exception. Reading flow: Declaration, validation, and representation follow a natural sequence; unfamiliar framework decorators and naming choices introduce minor friction.
Run 3
Code Structure: Imports and a small validator class are logically organized, though many imports are unused in this snippet. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: The class name and minimum-length check communicate the purpose, but parameter names such as data, mode, and limit are ambiguous; the docstring explains the callable-class design rather than the validation behavior. Code length: The implementation is concise, with little unnecessary logic. Action granularity: Each statement performs one clear action, although naming the error message key is misleading. Reading flow: Declaration, validation, and representation follow a natural order. The attrs-based field declaration requires some library familiarity, and spacing around the class could be improved.