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, inst, attr, value):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if len(value) < self.min_length:
msg = f"Length of '{attr.name}' must be >= {self.min_length}: {len(value)}"
raise ValueError(msg)
def __repr__(self):
return f"<min_len validator for {self.min_length}>"
Run 1
The code is well-structured with clear separation of imports, class definition, and methods. It uses a frozen and slotted attrs class, which makes intent explicit and prevents runtime mutation. Nesting is minimal—only a single if-statements inside the __call__ method. The purpose is obvious from the class name and docstring. The __repr__ improves debugging. The only minor issue is that the __call__ method could have type hints for clarity, and the docstring is a bit redundant but acceptable. Overall, it is concise, readable, and follows idiomatic Python practices, earning a high readability score.
Run 2
The code is generally clear and well-structured. It uses a frozen attrs class for a validator, which is logical. The method is short, flat, and has a clear purpose. However, readability is slightly reduced by the unnecessary import block (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, _AndValidator, and_, default_if_none, NotCallableError) that is not used in this snippet, creating ambiguity about dependencies. The __call__ method mixes validation logic and error message construction, but it remains concise. The docstring is brief and clarifies why a callable class is used. Overall, the core logic is readable, but the extraneous imports and minor mixing of concerns prevent a higher score.
Run 3
The code is generally clear and well-structured. It uses a frozen attrs class for a validator, which makes intent clear and the logic concise. The __call__ method has a single level of nesting, and the error message is informative. The __repr__ method improves debuggability. However, readability is slightly reduced by unused imports (operator, re, Pattern, contextmanager, etc.) which are unnecessary noise, and the docstring inside __call__ could be moved to the class level for clarity. Overall, the code is readable but could be cleaner by removing dead imports and relocating the docstring.
Run 1
Code Structure: The validator is logically organized into configuration, validation, and representation methods, though numerous unused imports distract from the snippet. Nesting: A single conditional keeps control flow shallow. Clarity of intent: Descriptive names and a clear error message make the minimum-length check obvious; the __call__ docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, with little unnecessary code beyond unused imports. Action granularity: Each statement performs one clear action, and message construction is separated from raising the exception. Reading flow: The class reads naturally from its minimum-length field through validation to representation, although a blank line separating standard-library and local imports would improve visual organization.
Run 2
Code Structure: The validator is logically organized into configuration, validation, and representation methods, although several unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive class and field names, a straightforward length check, and a clear error message communicate the purpose well; the __call__ docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, with little unnecessary code beyond the unused imports. Action granularity: Each line performs one clear action. Reading flow: The progression from minimum-length configuration to validation and representation is natural, though additional spacing between imports and the class would improve presentation.
Run 3
Code Structure: The validator is logically organized into configuration, validation, and representation methods, though numerous unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive class and attribute names, a direct length check, and an informative error message clearly communicate the purpose. The callable-method docstring explains the class design rather than the method's validation behavior. Code length: The implementation is concise, with little unnecessary code beyond the imports. Action granularity: Each statement performs one clear action. Reading flow: The progression from minimum-length configuration to validation and representation is natural; additional spacing between imports and the class would improve visual separation.