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 _MaxLengthValidator:
max_length = attrib()
def __call__(self, inst, attr, value):
if len(value) > self.max_length:
msg = f"Length of '{attr.name}' must be <= {self.max_length}: {len(value)}"
raise ValueError(msg)
def __repr__(self):
return f"<max_len validator for {self.max_length}>"
Run 1
The code is generally well-structured and readable. It follows clear conventions with a single class definition, focused imports, and minimal nesting. The class name indicates intent clearly, and the __call__ method contains one conditional block that handles validation—flat and easy to follow. The error message uses f-strings concisely, and __repr__ is informative. The only minor deductions are the blank line after the function definition line (stylistic) and the slightly redundant import of Pattern along with re, which could be streamlined. Overall, intent is unambiguous, actions are granular, and reading flow is natural.
Run 2
The code is highly readable. It has a clear, logical structure with a single frozen/slotted attrs class. Nesting is minimal (one `if` inside `__call__`). Intent is unambiguous: a validator enforcing maximum length. Code length is concise with no unnecessary lines; even the blank line before the `if` adds clarity. Action granularity is good, with dedicated lines for the condition, message construction, and raise. Reading flow is natural: imports, class definition, method logic, then repr. Minor note: imports `operator`, `re`, `Pattern`, `get_run_validators`, etc. are unused and could be removed, but they don't hinder readability.
Run 3
The code is relatively readable due to its simple structure and clear single-method class. The validation logic is straightforward and the error message is descriptive. However, readability is reduced by several factors: the imports are not used, the blank line at the start of `__call__` is unnecessary and disrupts flow, and `inst` is an unused parameter with no leading underscore to signal intent. The `repr=False` in the decorator is also unclear without additional context. Overall, it is functional but could be cleaner.
Run 1
Code Structure: The validator is logically organized into configuration, validation, and representation methods, although numerous unused imports distract from the small class. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, max_length attribute, and informative error message clearly communicate the length constraint; abbreviated parameters such as inst and attr are less explicit. Code length: The implementation is concise, but unused imports and an extra blank line add unnecessary clutter. Action granularity: Each statement performs one clear action, with message construction separated from raising the exception. Reading flow: The class reads naturally from its limit declaration through validation to representation, though missing spacing between imports and the class decorator slightly weakens presentation.
Run 2
Code Structure: The validator is logically organized into a field, validation method, and representation method; several unused imports add clutter. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: Descriptive class and field names, a straightforward length check, and an informative error message clearly convey the purpose, although framework decorators and abbreviated parameter names require some familiarity. Code length: The implementation is concise, with minor excess from unused imports and a blank line. Action granularity: Each statement performs one clear action. Reading flow: The progression from configuration to validation to representation is natural, though import clutter slightly distracts from the small implementation.
Run 3
Code Structure: The validator is logically organized into configuration, validation, and representation methods, though several imports are unused in this snippet. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: Descriptive class and attribute names, a straightforward length check, and an informative error message clearly communicate its purpose; the attrs framework requires some familiarity. Code length: The implementation is concise, with minor clutter from unused imports and an unnecessary blank line. Action granularity: Each statement performs one clear action. Reading flow: The sequence from the length limit to validation and representation is natural, with consistent formatting overall.