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 highly readable. It follows logical structure with clear separation of imports, class definition, and methods. Nesting is minimal (single if statement). The intent is immediately clear: a validator class that checks minimum length. The class uses modern Python features like @attrs decorator with frozen=True and slots=True for efficiency and immutability. The __call__ method clearly shows its purpose with a helpful docstring. Action granularity is appropriate - each meaningful operation is on its own line. The error message is descriptive and clear. Minor deductions: the redundant import of 'operator' and 're' at the top could confuse readers, and the unused imports slightly detract from clarity. The __repr__ method could benefit from a brief docstring for consistency. Overall, excellent readability with only minor cosmetic issues.
Run 3
The code is generally readable with a clear purpose: a minimal-length validator. It uses clean structure, flat nesting, and concise length. The use of the attrs library and a callable class is logical, and the one-action-per-line principle is mostly followed. However, readability is reduced by the unused imports (operator, re, Pattern, contextmanager, get_run_validators, set_run_validators, _AndValidator, and_, default_if_none, NotCallableError), which obscure intent and suggest leftover code. The docstring is helpful, but the message formatting could be clearer. Overall, the core logic is straightforward, but the noise from unused imports prevents a higher score.
Run 1
Code Structure: The validator class logically groups its configuration, validation behavior, and representation, although numerous unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive names and a specific error message clearly communicate minimum-length validation; the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, with little unnecessary code beyond the imports. Action granularity: Statements generally perform one action per line, and separating message construction from raising the exception improves readability. Reading flow: Configuration, validation, and representation appear in a natural sequence, supported by whitespace and consistent formatting.
Run 2
Code Structure: Imports and a small validator class are logically organized, though several imports appear unused in this snippet. Nesting: Only a single conditional keeps the code flat and easy to follow. Clarity of intent: Descriptive names and a helpful error message clearly communicate minimum-length validation; however, 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 statement performs one clear action. Reading flow: Configuration, validation, and representation follow a natural sequence, though an additional blank line before the top-level class would improve visual separation.
Run 3
Code Structure: Imports, class declaration, validation logic, and representation are logically organized, though several imports are unused in this snippet. Nesting: Only one conditional level keeps the code easy to follow. Clarity of intent: Descriptive names and a clear error message communicate minimum-length validation; the docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, with minor clutter from unused imports. Action granularity: Each line performs a single clear action, and message construction is separated from raising the exception. Reading flow: The progression from configuration to validation to representation is natural, although a blank line before the class decorator would improve visual separation.