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, a, b, c):
"""
We use a callable class to be able to change the ``__repr__``.
"""
if len(c) > self.max_length:
d = f"Length of '{b.name}' must be <= {self.max_length}: {len(c)}"
raise ValueError(d)
def __repr__(self):
return f"<max_len validator for {self.max_length}>"
Run 1
The code is generally readable and well-structured. It has a clear purpose: defining a max-length validator. Imports are organized, and the class uses sensible decorators. The __call__ method checks length and raises ValueError with a descriptive message, though single-letter parameter names (a, b, c) reduce clarity. The docstring explains why a class is used, which helps intent. Nesting is minimal. The custom __repr__ is helpful. However, the parameter names harm readability, and the conditional check could be slightly more explicit. Code length is concise and appropriate. Overall, it is readable but could be improved with better naming.
Run 2
The code demonstrates good readability with clear structure and low nesting (single-level if). The class is logically organized with minimal methods and clear intent. However, variable names (a, b, c) are very poor and cryptic, obscuring their purpose despite docstrings. The __call__ method signature would benefit from descriptive parameters. The action granularity is good—one action per line (length check, format, raise). The reading flow is natural: import, class definition, call method, repr. The use of attrs decorators is clean. The f-string is readable but variably named. Code length is appropriate for the task. Overall, strong structural clarity undermined by opaque parameter names, preventing a higher score.
Run 3
The code is generally readable: it has a logical structure, minimal nesting, clear intent, and concise length. Each logical action (length check, error message creation, exception raise) is separated appropriately. However, the use of single-letter variable names (a, b, c, d) in the __call__ method and the import of re/Pattern without usage in this snippet slightly reduce clarity. The error message construction also crams a conditional expression into one line, hurting action granularity.
Run 1
Code Structure: The validator class is logically organized, with configuration, validation, and representation separated into small methods, though numerous unused imports add clutter. Nesting: A single conditional keeps the code flat and easy to follow. Clarity of intent: The class name, max_length attribute, and error message clearly communicate the validation purpose, but parameter names a, b, c and temporary variable d obscure their roles. The docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although unused imports unnecessarily lengthen the snippet. Action granularity: Each statement performs one clear action, and message construction is separated from raising the exception. Reading flow: The class follows a natural progression, but cryptic names and import noise slightly interrupt comprehension.
Run 2
Code Structure: The validator is logically organized into an attribute, validation method, and representation method, though numerous unused imports add clutter. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, max_length attribute, and error message make the purpose clear, but parameter names a, b, c and temporary variable d obscure their roles. The docstring explains the callable-class design rather than the validation behavior. Code length: The implementation is concise, although imports could be reduced and the temporary error-message variable is unnecessary. Action granularity: Each line generally performs one action. Reading flow: The sequence is natural and easy to follow, with minor friction from vague names and unexplained decorator options.
Run 3
Code Structure: The validator is logically organized into initialization metadata, validation, and representation, though numerous unused imports add clutter. Nesting: A single conditional keeps the code shallow and easy to follow. Clarity of intent: The class name, max_length attribute, and error message clearly communicate length validation, but parameter names a, b, c and temporary variable d obscure their roles. The docstring explains the callable-class design rather than the method's behavior. Code length: The implementation is concise, although unused imports increase unnecessary length. Action granularity: Each line performs a distinct action, making individual operations easy to identify. Reading flow: The sequence from checking length to constructing an error and raising it is natural, followed by a straightforward representation method; more descriptive names and cleaner imports would improve readability.