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):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if len(value) > self.max_length:
raise ValueError((f"Length of '{attr.name}' must be <= {self.max_length}: {len(value)}"))
def __repr__(self):
return f"<max_len validator for {self.max_length}>"
Run 1
The code is well-structured and readable. It uses a frozen, slotted attrs class for a validator, which is logical and clear. The nesting is minimal (one if statement), and the intent is evident from the class name and docstring. The code length is concise and each line has a single action, promoting good granularity. Reading flow is natural, with a clear __call__ method and a custom __repr__ for debugging. Minor deductions: the blank line after the if statement could be removed, and the error message could be split for better line length control. The unused imports (operator, re, Pattern, contextmanager, etc.) at the top are not part of the class logic, but they slightly clutter the snippet and could confuse a reader about their usage.
Run 2
The code is mostly readable with clear structure and intent, but it has some issues that lower the score. The class definition is logical and the validator pattern is recognizable. However, there is an unnecessary blank line before the raise statement that disrupts flow, and the error message f-string is overly compact and hard to read. The `__call__` method mixes validation logic with formatting in one block. Imports include unused items (`operator`, `re`, `Pattern`, `contextmanager`, `get_run_validators`, `set_run_validators`, `_AndValidator`, `and_`, `NotCallableError`), suggesting boilerplate or copy-paste. The `__repr__` is clear. Nesting is flat, which is good, and action granularity is mostly one action per line. Overall, the code is understandable but could be cleaner and more concise.
Run 3
The code is well-structured and concise, with clear imports and a single class definition. It uses a frozen, slotted attrs class, which is idiomatic and readable. The method is short and has a single responsibility. The nesting is minimal. The main readability issue is the presence of an unnecessary blank line inside the if block before the raise statement, and the f-string is slightly long but still understandable. The docstring is helpful for explaining why a callable class is used. Overall, the intent is clear, the flow is natural, and the code avoids over-engineering.
Run 1
Code Structure: The validator class is logically organized, with configuration, validation, and representation clearly separated, although many imports are unused in this snippet. Nesting: Minimal nesting makes the validation path easy to follow. Clarity of intent: Class and attribute names clearly communicate the maximum-length constraint, and the error message is informative. However, the __call__ docstring explains the class design rather than the method's behavior. Code length: The implementation is concise, but redundant parentheses around the error message and an unnecessary blank line add minor clutter. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural order, though the long raise statement and limited spacing between imports and the class slightly reduce readability.
Run 2
Code Structure: The validator is logically organized into configuration, validation, and representation, though numerous unused imports add clutter. Nesting: A single conditional keeps the implementation flat and easy to follow. Clarity of intent: Descriptive class and attribute names make the maximum-length check clear; however, the __call__ docstring explains representation design rather than validation behavior. Code length: The implementation is concise, but unused imports, redundant parentheses around the error message, and an extra blank line are unnecessary. Action granularity: Each statement performs one clear action. Reading flow: The class reads naturally from stored limit to validation to representation, although the long raise statement and excess imports slightly interrupt readability.
Run 3
Code Structure: The validator is logically organized into configuration, validation, and representation methods, though many imports are unused in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, max_length attribute, and error message clearly communicate maximum-length validation; the docstring explains the callable-class choice rather than the method's behavior. Code length: The implementation is concise, but unused imports, redundant parentheses around the error message, and an extra blank line add clutter. Action granularity: Each statement performs one clear action. Reading flow: The class reads naturally from initialization metadata through validation to representation, although the long raise statement and inconsistent spacing slightly disrupt scanning.